2D block image encoding

ABSTRACT

A coder (e.g., an encoder or decoder) implements coding of two dimensional blocks of image data using two dimensional differential pulse code modulation (2D DPCM). The coder may switch between DPCM and other types of coding, such as transform coding on a block by block basis. The 2D DPCM may obtain a reconstructed pixel within the two dimensional bloc and code a second, different, pixel within the two dimensional block using the reconstructed pixel. The coder may also create a bitstream of entropy encoded residuals that supports hybrid implicit/explicit specification of coding parameters.

CROSS REFERENCE TO RELATED APPLICATIONS

This application claims priority to provisional application Ser. No.61/709,316, filed 3 Oct. 2012 which is entirely incorporated herein byreference. This application also claims priority to provisionalapplication Ser. No. 61/764,807, filed 14 Feb. 2013, provisionalapplication Ser. No. 61/764,891, filed 14 Feb. 2013, provisionalapplication Ser. No. 61/770,979, filed 28 Feb. 2013, provisionalapplication Ser. No. 61/810,126, filed 9 Apr. 2013, provisionalapplication Ser. No. 61/820,967, filed 8 May 2013, provisionalapplication Ser. No. 61/832,547, filed 7 Jun. 2013, and provisionalapplication Ser. No. 61/856,302, filed 19 Jul. 2013.

TECHNICAL FIELD

This disclosure relates to image processing. This disclosure alsorelates to compression and decompression techniques for imagetransmission and display.

BACKGROUND

Immense customer demand has driven rapid advances in displaytechnologies, image analysis algorithms, and communication technologies,as well as the widespread adoption of sophisticated image displaydevices. As just a few examples, these devices range from DVD andBlu-ray players that drive high resolution displays for home theaters,to the now ubiquitous smart phones and tablet computers that also havevery high resolution displays. Improvements in image processingtechniques will continue to expand the capabilities of these devices.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows an example architecture in which a source communicatesencoded data to a sink.

FIG. 2 is an example of an encoder.

FIG. 3 shows a parallel processing architecture.

FIG. 4 shows an example of a predictor and quantizer.

FIG. 5 shows example sample locations.

FIG. 6 shows examples of a coded format for compressed samples.

FIG. 7 shows an example of a virtual buffer model.

FIG. 8 shows an example decoder.

FIG. 9 shows example logic for encoding.

FIG. 10 shows example logic for decoding.

FIG. 11 shows an example encoding and decoding system.

FIG. 12 shows an example of a picture and a picture parameter set.

FIG. 13 shows another example of an encoder.

FIG. 14 shows another example of a decoder.

FIG. 15 illustrates samples sets for block search.

FIG. 16 illustrates an example of indexed color history.

FIG. 17 shows an example of a portion of a slice using substreammultiplexing.

FIG. 18 shows an example of substream demultiplexing logic.

FIG. 19 shows an example of substream multiplexing logic.

FIG. 20 shows an example of slice timing and delays.

FIG. 21 shows an example of 3×1 partial SADs that form 9×1 SAD.

FIG. 22 shows an example of original pixels used for encoder flatnesschecks.

FIG. 23 shows examples of 2D blocks of pixels.

FIG. 24 shows an example encoding scenario for 2D blocks of pixels.

FIG. 25 shows an example of encoder logic.

DETAILED DESCRIPTION

FIG. 1 shows an example architecture 100 in which a source 150communicates with a sink 152 through a communication link 154. Thesource 150 or sink 152 may be present in any device that manipulatesimage data, such as a DVD or Blu-ray player, a smartphone, a tabletcomputer, or any other device. The source 150 may include an encoder 104that maintains a virtual buffer 114. The sink 152 may include a decoder106, memory 108, and display 110. The encoder 104 receives source data112 (e.g., source image data) and may maintain the virtual buffer 114 ofpredetermined capacity to model or simulate a physical buffer thattemporarily stores compressed output data. The encoder 104 may alsoevaluate the encoded symbols for transmission at a predetermined bitrate. The encoder 104 may specify the bit rate, as just two examples, inunits of bits per pixel, or in units of bits per unit of time.

The encoder 104 may determine the bit rate, for example, by maintaininga cumulative count of the number of bits that are used for encodingminus the number of bits that are output. While the encoder 104 may usea virtual buffer 114 to model the buffering of data prior totransmission of the encoded data 116 to the memory 108, thepredetermined capacity of the virtual buffer and the output bit rate donot necessarily have to be equal to the actual capacity of any buffer inthe encoder or the actual output bit rate. Further, the encoder 104 mayadjust a quantization step for encoding responsive to the fullness oremptiness of the virtual buffer. An exemplary encoder 104 and operationof the encoder 104 are described below.

The decoder 106 may obtain the encoded data 116 from the memory 108.Further, the decoder 106 may determine the predetermined virtual buffercapacity and bit rate, and may determine the quantization step that theencoder 104 employed for encoding the encoded data 114. As the decoder106 decodes the encoded data 116, the decoder 106 may also determine thefullness or emptiness of the virtual buffer 114 and adjust thequantization step used for decoding. That is, the decoder 106 may trackthe operation of the encoder 104 and determine the quantization stepthat the encoder 104 used. The decoder 106 decodes the encoded data 116and provides video data 118 to a display 110. In some implementations,the quantization step is not present in the encoded data 116, savingsignificant bandwidth. Examples of decoders 106 and encoders 104, andtheir operation are described below.

The memory 108 may be implemented as Static Random Access Memory (SRAM),Dynamic RAM (DRAM), a solid state drive (SSD), hard disk, or other typeof memory. The display link 154 may be a wireless or wired connection,or combinations of wired and wireless connections. The encoder 104,decoder 106, memory 108, and display 110 may all be present in a singledevice (e.g. a smartphone). Alternatively, any subset of the encoder104, decoder 106, memory 108, and display 110 may be present in a givendevice. For example, a Blu-ray player may include the decoder 106 andmemory 108, and the display 110 may be a separate display incommunication with the Blu-ray player.

FIG. 2 shows an example of an encoder 200. The encoder 200 encodes thevideo data 202. The video data 202 may take the form of a series ofsuccessive frames 202-0, . . . , 202-x, for example. The frames 202-0, .. . , 202-x may take the form of 2-dimensional matrices of pixelcomponents, which may be represented in any color space such as theRed/Green/Blue (RGB), YUV, Luminance Y/Chroma Blue Cb/Chroma Red Cr(YCbCr), Luminance Y/Chroma Orange/Chroma Green (YCoCg), Alpha, Red,Green, Blue (ARGB), or other color space. Each of the pixel componentsmay correspond to a spatial location. While the matrices may be overlaidto form a picture, each of the pixel components in the matrices are notnecessarily co-located with pixel components in other matrices.

Each pixel component may be encoded with a value comprising apredetermined number of bits, such as eight, ten, or twelve bits perpixel component. The encoding may employ, as examples, 10 bit YCbCr4:2:2, 8 bit YCbCr 4:2:2, 10 bit YCbCr 4:4:4, 8 bit YCbCr 4:4:4, 8 bitARGB 32, or 8 bit RGB 24 encoding. The encoder 200 may receive the pixelcomponents of the frames in raster scan order: left to right, top tobottom. In certain implementations, the video encoder 200 may receivethe pixel components at a predetermined rate. The predetermined rate maycorrespond to the real-time frames per second display rate.

The video encoder 200 may include an input, predictor & quantizer 204, amapping and variable length coder (VLC) 206, rate controller 208, a ratebuffer 210, and memory (e.g., DRAM) 212. The video encoder 200 receivesand encodes the pixel components. While the number of bits representingpixel components coming into the video encoder 200 may be constant (perpixel component), the number of bits representing each coded pixel mayvary dramatically. The encoder 200 may increase the number of bitsrepresenting coded pixels by reducing the quantization step, or decreasethe number of bits by increasing the quantization step.

The input, predictor & quantizer 204 predicts and quantizes the pixelcomponents, resulting in quantized residuals. In certainimplementations, the input, predictor, & quantizer 204 may predict apixel component from previously encoded and reconstructed pixelcomponents in the same frame, e.g., 202-0. The mapper and variablelength coder 206 codes the quantized residuals, resulting in coded bits.

The input, predictor & quantizer 204 may use a predetermined initialquantization step for quantizing a predetermined amount of data, such asvideo pixel data. The mapping and variable length coder 206 signals therate controller 208, which in turn instructs the input, predictor &quantizer 204 to increment, decrement, or leave unchanged thequantization parameter, as will be described in more detail below.

The mapping and variable length coder 206 may code the quantized samplevalues using their natural 2's complement binary values. The number ofbits that the mapping and variable length coder 206 uses to code eachvalue may be determined dynamically by a combination of recent historyof coded values of the same pixel component and a prefix valueassociated with each unit of samples.

The rate controller 208 determines whether to increment, decrement, orleave unchanged the quantization step. The rate controller 208 mayperform the quantization step analysis, e.g., by simulating or modelinga buffer of predetermined capacity that it evaluates at a predeterminedbit rate. The modeled buffer may be referred to as a virtual buffer. Ifthe virtual buffer is becoming full, the rate controller 208 mayincrease or increment the quantization step. If the virtual buffer isbecoming empty, the rate controller 2098 may decrease or decrement thequantization step. Further aspects of this are described below withrespect to rate control for slices.

The rate controller 208 may determine the fullness of the virtual bufferby, e.g., counting the bits that are used to encode the input receivedover a given number of input samples and subtracting the product of thepredetermined bit rate, in bits per sample, and the number of inputsamples. The number of input samples may be as few as one sample.

A decoder may decode the encoded data starting with the initialquantization step. As the decoder decodes the encoded data, the decodermay also determine the fullness of the virtual buffer. The decoder maydetermine the fullness or emptiness by observing the amount of bits thatwere used to encode an amount of decoded data corresponding to thenumber of input samples. The decoder may then determine the quantizationstep decision that was made at the encoder 200. Accordingly, the encoder200 does not need to explicitly transmit the quantization step to therate controller or any other logic in the decoder.

FIG. 3 shows a parallel processing architecture 300. The demultiplexer302 receives the input pixel components 304, and separates each pixelcomponent into constituent parts, e.g., Alpha 306, Red 308, Green 310,and Blue 312. The prediction & quantization blocks 314, 316, 318, and320 are associated with a particular one of the constituent parts of thepixel components. There may be any number of such blocks and they mayoperate in parallel. In the case of a format with four pixel components,such as ARGB, each prediction & quantization block processes aparticular component part. When the architecture 300 processes pixelcomponents with fewer constituent parts than prediction & quantizationblocks, then some of the prediction & quantization blocks need notoperate for the processing of those pixel components. The prediction &quantization blocks 314-320 may provide quantized residuals to aparticular one of component mappers 322, 324, 326, and 328. Thecomponent mappers 322-328 may also operate in parallel.

The mappers 322-328 provide mapped quantized residuals ‘E’ to amultiplexer 330. The multiplexer 330 multiplexes the mapped quantizedresiduals ‘E’ into a residual stream 332 that is provided to thevariable length coder 334. Alternatively, there may be a variable lengthencoder associated with each component mapper, and the multiplexer 330may multiplex the variable length encoded quantized residuals output bythe multiple variable length encoders.

FIG. 4 shows an example of a predictor and quantizer 400. The predictorand quantizer 400 includes a buffer 402, first delay logic 404(implementing, e.g., six sample delay), a prediction engine 406, andsecond delay logic 408 (implementing, e.g., 3 sample delay). The buffer402 may store the previous reconstructed image line. The predictionengine 406 receives the current pixel component ‘x’, reconstructed pixelcomponents ‘w’, ‘t’, ‘s’, ‘g’, ‘c’, ‘b’, ‘d’, and ‘h’ from the previousline from the first delay blocks 404, and reconstructed pixels from theleft on the current line, ‘k’, ‘r’, ‘f’, ‘a’ from the second delayblocks 408.

In order to use reconstructed pixel components, instead of the inputpixel components, the quantizer 410 may provide quantized residuals E′to an inverse quantizer 412. The inverse quantizer 412 inverse quantizesthe quantized residuals. The reconstructed pixels ‘Rx’ are generatedfrom the quantized residuals E′ and the predicted values from theprediction engine.

The prediction engine 406 may include an Edge prediction engine 414, LSprediction engine 416, Left prediction engine 418, and ABCD predictionengine 420. As described above, the prediction engine 406 predicts thecurrent pixel component ‘x’ from reconstructed pixel components ‘w’,‘t’, ‘s’, ‘g’, ‘c’, ‘b’, ‘d’, and ‘h’ from the previous line, andreconstructed pixels from the left on the current line, ‘k’, ‘r’, ‘f’,‘a’, thereby resulting in a residual E″ representing the pixel component‘x’.

The operation of the prediction engine 406 will now be described withreference to FIG. 5, which shows example pixel components 500. Theprediction engine 406 may adaptively predict pixel components fromneighboring reconstructed pixels of the line above, and the left pixelsof the same line of the pixel to be predicted. For example, theprediction engine 406 may predict pixel ‘x’ from a combination of any ofthe reconstructed pixels ‘t’, ‘s’, ‘g’, ‘c’, ‘b’, ‘d’, ‘h’, ‘k’, ‘r’,‘f’, and ‘a’.

The spatial prediction adaptively chooses an output from one of the fourcandidate prediction engines: the Edge prediction engine 414, LSprediction engine 416, Left prediction engine 418, and ABCD predictionengine 420 as its predictor for the current pixel component. The choicemay be made according to the prediction errors determined for one ormore previous reconstructed pixel components, considering the candidatepredictors. This operation may be the same in both the encoder anddecoder, and no prediction control information needs to be included inthe encoded data. The decoder may implement an identical prediction modealgorithm and deduce the prediction mode used by the encoder. Once apredictor is selected, the value of each sample is predicted using theselected predictor. The residual value E″ is calculated as thedifference between the predicted value and the actual sample value.

LS Prediction Engine 416

The LS prediction engine 416 may produce a predicted value Px of thecurrent sample ‘x’ according to the following:

if (c >= max(a, b)) Px = min(a, b); else { if (c <= min(a, b)) Px =max(a, b); else Px = a + b − c;}

ABCD Prediction Engine 420.

The ABCD prediction engine 420 may produce the prediction valuePx=(a+b+c+d+2)/4. This is an average of four neighboring samples.

Left Prediction Engine 418

The Left prediction engine 418 may use the reconstructed value of theleft pixel of the current sample as its prediction value. In otherwords, Px=‘a’.

Edge Prediction Engine 414

The Edge prediction engine 414 may employ more neighboring pixels thanthe LS prediction engine 416. The Edge prediction engine 414 may detectan edge at several possible angles around the current sample ‘x’, anduse the edge information in the prediction. The Edge prediction engine414 may search, as examples, for directions of an edge that arehorizontal, vertical, 45 degree, 135 degree, about 22.5 degrees andabout 157.5 degrees. The Edge prediction engine 414 may be implementedin two stages. The first stage is edge detection. The second stage isedge selection.

Some options may be specified for the prediction function. The use ofthe reconstructed sample value ‘a’, which is immediately to the left of‘x’, may be disabled by configuring the Edge prediction engine 414 witha parameter such as NOLEFT=1. Avoiding the use of sample ‘a’ may allowmore time for the prediction, quantization and inverse quantization pathto function, which may be an advantage in high throughput systems wherecircuit timing may make it difficult to reconstruct sample ‘a’ quickly.The use of the reconstructed sample values ‘a’ and ‘f’, which are thetwo samples immediately to the left of ‘x’, may be disabled byconfiguring the Edge prediction engine 414 with a parameter such asNOLEFT=2 (also referred to as NO2LEFT). This allows even more time forthe prediction, quantization and inverse quantization path to function.When circuit timing needs three clock cycles for prediction,quantization and inverse quantization, the use of NOLEFT=2 facilitates athroughput of one sample per clock.

The individual prediction engines from the four listed above may beselectively enabled and disabled. For certain classes of content, betterperformance may be obtained by utilizing a subset of the predictionfunctions. When predicting samples along the top and left edges of animage, for example, the Left prediction engine 418 may be employed, asspecified below.

NOLEFT=1 Option

When NOLEFT=1, the reconstructed sample value ‘a’ in the LS predictionengine 416, ABCD prediction engine 418, and Edge prediction engine 420is replaced by its prediction Pa using the reconstructed samples ‘f’,‘g’, and ‘c’ according to the following:

if (ABS(g−c) > ABS(g−f)*3) Pa = c; else { if (ABS(g−f) > ABS(g−c)*3) Pa= f; else Pa = (f+c+1)/2;}

NOLEFT=2 Option

When NOLEFT=2, the reconstructed sample values ‘f’ and ‘a’ in the LSprediction engine 416, ABCD prediction engine 418, and Edge predictionengine 420 are replaced by their predictions Pf and Pa using thereconstructed samples ‘r’, ‘s’, ‘g’, and ‘c’. The prediction of ‘a’ mayuse the same approach as in NOLEFT, except that ‘f’ is replaced by Pfaccording to the following:Pf =(r+g+s+c+2)/4;

Edge prediction engine with NOLEFT=0, NOLEFT=1, NOLEFT=2

When NOLEFT=0, the left sample is used in the prediction, and thefollowing may be applied to the edge detection:

if ( (2*ABS(a−c) > 6*ABS(c−b)) && 2*ABS(a−c) > 6*ABS(c−g) && 2*ABS(a−c) > 6*ABS(a−f) ) { edge1 = 0; strength1 = ABS(c−b); } else if (2*ABS(b−c) > 6*ABS(c−a) && 2*ABS(c−d) > 6*ABS(c−a) ) { edge1 = 1;strength1 = ABS(c−a) ; } else { strength1 = max_strength; edge1 = 7; }if ( 2* ABS(a−g) > 6*ABS(a−b) && 2* ABS(a−g) > 6*ABS(f−c) ) { edge2 = 2;strength2 = ABS(a−b); } else if( 2* ABS(a−b) > 6*ABS(a−g) && 2*ABS(a−b) > 6*ABS(s−f)) { edge2 = 3; strength2 = ABS(a−g) ; } else {strength2 = max_strength; edge2 = 7; } if ( 2*ABS(a−g) > 6*ABS(a−d) ) {edge3 = 4; strength3 = ABS(a−d) ; } else if ( 2*ABS(a−b) > 6*ABS(a−s) ){ edge3 = 5; strength3 = ABS(a−s) ; } else { strength3 = max_strength;edge3 = 7; }

When NOLEFT=1, the left sample is not used in the prediction, and thefollowing may be applied to the edge detection:

if ( (2*ABS(f−g) > 6*ABS(c−g)) && 2*ABS(f−g) > 6*ABS(s−g) && 2*ABS(f−g) > 6*ABS(r−f) ) { edge1 = 0; strength1 = ABS(c−g); } else if (2*ABS(g−c) > 6*ABS(f−g) && 2*ABS(b−g) > 6*ABS(g−f) ) { edge1 = 1;strength1 = ABS(f−g); } else { strength1 = max_strength; edge1 = 7; } if( 2* ABS(f−s) > 6*ABS(f−c) && 2* ABS(f−s) > 6*ABS(r−g) ) { edge2 = 2;strength2 = ABS(f−c); } else if ( 2* ABS(f−c) > 6*ABS(s−f) && 2*ABS(f−c) > 6*ABS(r−t) ) { edge2 = 3; strength2 = ABS(s−f); } else {strength2 = max_strength; edge2 = 7; } if ( 2*ABS(s−f) > 6*ABS(f−b) ) {edge3 = 4; strength3 = ABS(f−b); } else if ( 2*ABS(f−c) > 6*ABS(f−t) ) {edge3 = 5; strength3 = ABS(f−t); } else { strength3 = max_strength;edge3 = 7; }

When NOLEFT=2, the two left samples are not used in the prediction, andthe following may be applied to the edge detection:

if ( (2*ABS(r−s) > 6*ABS(g−s)) && 2*ABS(r−s) > 6*ABS(t−s) && 2*ABS(r−s) > 6*ABS(k−r) ) { edge1 = 0; strength1 = ABS(g−s); } else if (2*ABS(s−g) > 6*ABS(r−s) && 2*ABS(c−s) > 6*ABS(s−r) ) { edge1 = 1;strength1 = ABS(r−s); } else { strength1 = max_strength; edge1 = 7; } if( 2* ABS(r−t) > 6*ABS(r−g) && 2* ABS(r−t) > 6*ABS(k−s) ) { edge2 = 2;strength2 = ABS(r−g); } else if ( 2* ABS(r−g) > 6*ABS(t−r) && 2*ABS(r−g) > 6*ABS(k−w) ) { edge2 = 3; strength2 = ABS(t−r); } else {strength2 = max_strength; edge2 = 7; } if ( 2*ABS(t−r) > 6*ABS(r−c) ) {edge3 = 4; strength3 = ABS(r−c); } else if ( 2*ABS(r−g) > 6*ABS(r−w) ) {edge3 = 5; strength3 = ABS(r−w); } else { strength3 = max_strength;edge3 = 7; }

The parameter ‘max_strength’ may be defined as the largest possibleabsolute difference between two samples. This parameter may be relatedto the pixel data format, e.g., for 8-bit data, max_strength=255, for10-bit data, max_strength=1023. The same edge selection logic may beapplied in each case of NOLEFT=0, NOLEFT=1 and NOLEFT=2, except that thesample value ‘a’ may be replaced by its prediction Pa when NOLEFT=1 orNOLEFT=2, and the sample value ‘f’ may be replaced by its prediction Pfwhen NOLEFT=2:

if (strength1 <= strength2) { if (strength1 <= strength3) { edge =edge1; strength = strength1; } else { edge = edge3; strength =strength3; } } else { if (strength2 <= strength3) { edge = edge2;strength = strength2; } else { edge = edge3; strength = strength3; } }if (strength == max_strength || edge == 7) Px = (a+c+b+d+2) / 4; else {switch(edge) { case 0: Px = a; case 1: Px = b; case 2: Px = d; case 3:Px = c; case 4: Px = h; case 5: Px = g; } }

Predictor Selection

A Unit may be considered to be a logical grouping of adjacent samples ofthe same component. For example, the Unit size may be selected to beequal to two. A Unit size may be the number of samples comprised by aUnit. In alternative implementations, the Unit size may be selected tohave a value of one, three, four or another value. In one embodiment,when the Unit size is selected to be equal to two, for every pair ofsamples of one component, a selected set (up to all) of the candidatepredictors may be evaluated using the previous pair of samples of thesame component, and the predictor that performs best for that previouspair is selected for the current pair. The selection of a predictor maybe made on boundaries that do not align with Units. There may be certainexceptions under which the set of candidate predictors is restricted,for example when samples to the left or above are not available, or forexample when one or more predictors are not enabled.

For the first pair of samples of the image, e.g., the two samples on theleft edge of the top line, the Left prediction engine 418 may beselected as the predictor. Further, for the first pair of samples ofeach line other than the first, the LS prediction engine 418 may beselected. Sample values that are not available for use in prediction maybe assigned a pre-determined value, for example one half of the maximumrange of sample values.

For other pairs of samples, the predictor may be selected according tothe estimated prediction errors of the left pair of samples, which maybe calculated by all four predictors. When the reconstructed value ofthe current sample ‘x’ is found, the estimated prediction error for thecurrent sample can be calculated as follows:err_sample=ABS(x′−Px)

In the above equation, Px is the predicted value of the current samplefrom each of the four predictors. The prediction error of one predictoris the sum of err_sample over both samples in a pair of samples for apredictor. The predictor with the smallest prediction error is thenselected as the predictor for the next pair of samples of the samecomponent.

Note when NOLEFT=1, the prediction error of the left sample is notavailable. Assuming the current sample is ‘x’ in FIG. 5, then ifNOLEFT=0, the prediction engine selected by the left pair, the samplesof ‘f’ and ‘a’, is used for the current sample pair. If NOLEFT=1, thepredictor selected by the smallest prediction error of the availableleft pair may be used, e.g., the samples of ‘r’ and ‘f’ if ‘x’ is thesecond sample of the pair, or samples of ‘r’ and ‘k’ is ‘x’ is the firstsample of the pair. If NOLEFT=2, the predictor selected by the smallestprediction error of the samples of ‘r’ and ‘k’ may be used if ‘x’ is thefirst sample of the pair, or samples of ‘k’ and its immediately left oneif ‘x’ is the second sample of the pair. The residual or error value E″may be determined as: E″=x−Px.

The reconstructed sample value of ‘x’, for use in future predictions,may be obtained as follows:x′=Px+E′*QuantDivisor;if (x′<0)x′=0;else if (x′>MAXVAL)x′=MAXVAL;

The value QuantDivisor is defined below. MAXVAL is the maximum valuethat can be coded by the uncompressed video sample word size, e.g., 1023for 10 bit video, and 255 for 8 bit video. In one implementation, Cb andCr are non-negative integers.

The operation of the mapper and variable length coder 206 is describedwith reference to FIG. 6, which shows examples of sample units 600,which are also referred to as Units. The mapper and variable lengthcoder 206 may use entropy coding to code sample values using theirnatural 2's complement binary values. The number of bits used to codeeach value may be determined dynamically by a combination of the recenthistory of coded values of the same component and a prefix valueassociated with each Unit 605 of samples. In certain implementations, aUnit 605 comprises two samples 610 of a particular component type, e.g.,Y, Cb or Cr, or Alpha, R, G or B. In some implementations, the Cb and Crsamples are coded together in one Unit. The same set of components maybe used for the prediction of the number of bits.

Each Unit 605 of samples has a Unit sample size. A Unit sample size maybe the size in bits of each of the samples in a Unit. The Unit 605sample size may be large enough to code each of the samples contained inthe Unit 505, and it may be larger. The size of one sample may be thenumber of bits used to code the sample's value in 2's complement. Forexample, a value of 0 has a size of 0, a value of −1 has a size of 1, avalue of −2 or 1 has a size of 2, a value of −4, −3, 2 or 3 has a sizeof 3, and so on.

A Unit 605, may have a maximum sample size, which is the maximum of thesizes of all the samples in the Unit 605. A Unit 605 may also have apredicted size. In one implementation, if the predicted size is greaterthan or equal to the maximum sample size, then the Unit 605 sample sizeis equal to the predicted size. In one implementation, if the maximumsample size is greater than the predicted size, then the difference,which is always non-negative, is coded in the prefix value 612, and themaximum sample size may be used as the Unit 605 sample size. In anotherimplementation, if the maximum sample size is different from thepredicted size, then the difference, which may be positive or negative,is coded in the prefix value 612. The prefix value may use unary coding,e.g., for implementations with non-negative prefix values, the value 0has the code 1 (binary), the value 1 has the code 01, the value 2 hasthe code 001, and so on. The Unit sample size is the sum of thepredicted size and the prefix value 612. For 10 bit video, the greatestpossible sample size is 10, and the smallest possible predicted size is0, so the greatest possible prefix value is 10, which occupies 11 bitsi.e. 0000 0000 001. For implementations with signed prefix values,signed prefix values may be unary coded.

The predicted size may be a function of the sizes of previously codedsamples. In one implementation, the predicted size is the average, withrounding, of the sizes of the samples of the same component of theprevious two samples, e.g., of the previous Unit, given that the Unitsize is 2. If the Unit size is 4, the predicted size may be the averageof the sizes of the four samples of the same component of the previousUnit. If the Unit size is 3, the predicted size may be generated by theaverage of the sizes of the last two samples of the same component ofthe previous Unit, thereby avoiding division by 3. Alternatively, if theUnit size is 3, the predicted size may be generated as a weighted sum of3 samples of the previous unit of the same component. The weights maybe, for example, (¼, ¼, ½).

For example, if a component of an image, after quantization, is suchthat the size of the samples is 2 for many consecutive samples, then thepredicted size is 2, and the prefix value is 0. Therefore the prefixcode is ‘1’, and each sample is coded using 2 bits, and a Unit of twosamples has a total of 5 bits. In the event of a transient causing asudden increase in the sample size, the prefix value codes the increasein the sizes. In the event of another transient causing a suddendecrease in the sample size, the prefix value may be 0 and the Unitsample size may be equal to the predicted size, which may be in excessof the sizes of the samples in the Unit. Therefore each sample may becoded with a number of bits equal to the predicted size, even thoughtheir own sizes are less. Following a transient, in the absence ofanother change in sample sizes, the Unit sample size and predicted sizeconverge again. This technique results in very efficient coding ofsamples, given that the sizes of the samples may change from Unit toUnit, particularly when the sizes do not frequently change very rapidly.

The delta size Unit variable length coding (DSU-VLC) scheme facilitatesefficient encoding and decoding at high speed in hardware, in partbecause it does not rely upon VLC tables. The number of bits in a Unitto be decoded is determined from the prefix value (counting zeros) andthe predicted size, which can be determined before encoding or decodingthe current Unit. It is feasible to encode or decode one Unit per clock,and faster decoding approaches are also feasible. Encoding can encodemultiple Units in parallel, for greater throughput. The Unit size may beselected to be greater than two for various reasons. For example, largerUnit size may be chosen where the usage imposes a throughput requirementthat cannot practically be met with a Unit size of 2, in which case aUnit size of 3 or 4 may be used.

Referring again to FIG. 4, the quantizer 410 quantizes the residuals E″,which in general includes the case of lossless coding, using aquantization parameter Quant. Quant may take on values ranging from 0,signifying lossless, to the value that corresponds to the highest valueof QuantDivisor[ ] (see below). With an exemplary set of values ofQuantDivisor and QuantOffset shown below, the value of Quant ranges from0 to 17.

The quantizer 410 may perform quantization on the residual value E″ asfollows:

if (Quant = 0) E′ = E″; else if (E″ >= 0) E′ = (E″ + QuantOffset[Quant])/ QuantDivisor[Quant]; else E′ = (E″ − QuantOffset[Quant]) /QuantDivisor[Quant];

where division may be with truncation, as, e.g., in the ‘C’ language.

The set of divisors may be:

int QuantDivisor[ ]={1, 3, 5, 7, 9, 10, 12, 14, 16, 18, 20, 24, 28, 32,48, 64, 128, 256};

The associated set of offsets, the rounding constants, may be:

int QuantOffset[ ]={0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 11, 13, 15, 23, 31,63, 127};

In this approach, there are 4 odd-valued divisors (3, 5, 7 and 9), andseven that are products of one of these odd-valued divisors and one offive other values, each of which is a power of 2:2**N. As a result, inone implementation, the quantization function supports 4 odd-valueddivisors.

The use of this particular set of values of QuantDivisor[ ] providesgood compression with low complexity. Note that division by the oddnumbers can be performed in hardware using multiplication by one of asmall set of optimized constant values.

In other implementations, the divisors may be selected such that they donot have odd factors. For example:

int QuantDivisor[ ]={1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048,4096};

int QuantOffset[ ]={0, 0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023,2047};

Rate Control

The value of Quant is determined via a rate control technique, which maybe performed identically in both the encoder and decoder. The ratecontrol technique may base its decisions on a measure of the activity ofthe most recently coded predetermined number of pixel components and onthe fullness of the buffer model. The predetermined number may be, forexample, 3, 2, or some other number. The value of Quant may be updatedonce per coded predetermined number of pixel components.

FIG. 7 shows an example of a virtual buffer model 700. The virtualbuffer model 700 is in communication with a bitstream source 702, therate controller 208, and a bitstream consumer 706. The virtual buffermodel 700 models the behavior of a rate buffer where the output bit rateis a specified bit rate. The specified bit rate may be in units of bitsper pixel or per group of pixels, or it may be in other units such asbits per unit of time, such as bits per second. The bitstream consumer706 may model the consumption of bits at a specified rate. The bitstreamsource 702 may be the output of the mapper and variable length coder206, for example. A group of pixels may comprise a predetermined numberof pixels, for example two, three, four, or some other number.

Bits enter the virtual buffer model 700 when they are created. Forexample, the number of bits used to code a Group is added to the model700 when the Group is coded. Bits leave the virtual buffer model 700according to a pre-determined schedule. For example, the schedule mayspecify a constant rate in units of bits per group. The virtual buffermodel 700 may be implemented as an accumulator 708, in which one valueis added and other value is subtracted per Group. Alternatively, theschedule of removing bits from the virtual buffer model 700 may be inunits of bits per second. Alternatively, the times at which bits areadded to or subtracted from the buffer model 700 may be finer or coarserthan a Group, and may use a construct other than a Group, such as asample, a macroblock, a slice or a picture. In order to model thebehavior of a First In First Out (FIFO) buffer, the fullness of thevirtual buffer model 700 may be clamped to 0 when subtracting a numberof bits from the fullness that would otherwise result in a negativevalue of fullness.

When the output bit rate used in the virtual buffer model 700 is lessthan or equal to the actual bit rate at which bits are removed from therate buffer in an encoder, and the rate controller 704 ensures that thevirtual buffer model 700 does not overflow, the rate buffer also doesnot overflow. More generally, the encoder may use the virtual buffermodel 700 to manage the rate of creation of bits by the encoder suchthat another virtual buffer model, which may be applied later to theencoder's bit stream, does not overflow or underflow. The bit rate atwhich bits leave the virtual buffer model can be changed at any time toany supported value. If the actual rate at which bits leave the ratebuffer equals or approximates the rate at which bits leave the virtualbuffer model, the encoder's bit rate can be set to any supported bitrate with effectively instantaneous response. Because the rate controluses the virtual buffer model to manage the rate of creation of bits,the rate control function does not need to monitor the rate at whichbits leave the rate buffer.

In one implementation, the encoder and decoder perform identical ratecontrol (RC) decisions, which control the value of the quantizer, orQuant, without the encoder transmitting any bits that specificallyindicate quantization control. The rate control may depend on theactivity, measured by the sizes of the samples, of the previous Group,as well as fullness of the virtual buffer model, and a measure of thestrength of an edge, if any, in the preceding samples. The rate controlmay use several configurable thresholds. Units 605 are organized intoGroups 710. Groups 710 are utilized to organize the samples tofacilitate the buffer model and rate control. In another exemplaryimplementation, the decoder does not perform the same rate controldecisions as the encoder, and the encoder transmits bits which indicateat least a portion of the quantization control.

In one implementation, the encoder, including the rate controller 208,ensures that the virtual buffer model 700 never exceeds a definedmaximum fullness, while choosing quantization levels to maximize overallsubjective image quality. For some images and bit rates, both may beachieved relatively easily, while for others, the buffer fullness mayvary and approach or reach the size of the virtual buffer model 700 attimes and the quantization may vary and may reach the maximum allowedvalue at times.

The virtual buffer model 700 may represent a FIFO of predetermined size,BufferSize. The value of BufferSize may be chosen according to theparticular application. A larger size generally facilitates bettercompression for a given bit rate and image contents, and vice versa. Alarger size also implies a larger amount of space available in aphysical rate buffer, as well as potentially increased latency. In anexemplary implementation, at the start of a picture, the buffer model700 is initialized to be empty. Alternatively, the virtual buffer model700 fullness may be retained from one picture to the next, or it may beinitialized to some other value.

As each Group 710 of samples is encoded, the number of bits used to codethe Group is added to the accumulator in the virtual buffer model 700.After each Group is coded, a number equal to the budget of bits perGroup, e.g., the specified bit rate, is subtracted from the accumulator,with the result clamped to 0 to enforce non-negative fullness. Inimplementations where the decoder mimics the rate control of theencoder, the same operation happens in the decoder: as each Group isdecoded, the number of bits that the Group occupies is added to themodel and the specified bit rate, e.g., the budget number of bits perGroup, is subtracted, with the result clamped to 0. This way the encoderand decoder buffer models track exactly for every Group in each picture.The rate controller 208 can guarantee that the buffer fullness neverexceeds the defined maximum value, e.g., the buffer size, by adjustingthe value of Quant.

In one implementation, at the start of each picture, the quantizationvalue Quant is initialized to 0, corresponding to lossless coding. Inanother implementation, the value of Quant is initialized to a non-zerovalue. The value of Quant may be adjusted dynamically to avoidoverflowing the buffer model while maximizing the compressed imagequality. The rate control algorithm may facilitate encoding of difficultimages at low bit rates with minimum visible quantization errors, aswell as encoding difficult images at higher bit rates with no visiblequantization error.

In one implementation, the activity level of each Group is measured. Theactivity level may be the maximum quantized residual size of each Unitin the Group, times the number of samples in a Unit (e.g., either 2, 3,or 4), plus 1 (corresponding to a prefix value of 0), summed over all ofthe Units in the Group. The quantized residual sizes are afterquantization using the current value of Quant. As an example of 2samples per unit and 3 units per group, the numbers of bits for sample 0and 1 are SampleSize[0] and SampleSize[1] respectively. Assume themaximum of the two samples for unit 0 isMaxSizeUnit[0]=MAX(SampleSize[0], SampleSize[1]), then the activitylevel for the group isRcSizeGroup=MaxSizeUnit[0]+1+MaxSizeUnit[1]+1+MaxSizeUnit[2]+1. Anotherparameter that calculates the real number of bits coded in the lastGroup, e.g., BitsCodedCur, in example shown below, is also used indetermining whether the value of Quant should be increased, decreased,or left unchanged.

The following describes control of the quantization parameter, Quant,for an example where the virtual buffer size is 16 Kbits. In thisexample, “MaxBitsPerGroup” represents the pre-determined data rate inbits per group. Offset[ ] is a set of values that adjust the“target_activity_level” according to the fullness of the buffer model,which is represented by “Buffer_fullness”, and which is compared tovarious threshold values represented by BufTh1, BufTh2, and so on:

// Set target number of bits per Group according to buffer fullnessif(Buffer_fullness < BufTh1) { Target_activity_level = MaxBitsPerGroup +offset[0]; MIN_QP = minQP[0]; MAX_QP = maxQP[0]; } elseif(Buffer_fullness < BufTh2) { Target_activity_level = MaxBitsPerGroup +offset[1]; MIN_QP = minQP[1]; MAX_QP = maxQP[1]; } elseif(Buffer_fullness < BufTh3) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[2])); MIN_QP = minQP[2]; MAX_QP = maxQP[2]; }else if(Buffer_fullness < BufTh4) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[3] )); MIN_QP = minQP[3]; MAX_QP = maxQP[3]; }else if(Buffer_fullness < BufTh5) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[4] )); MIN_QP = minQP[4]; MAX_QP = maxQP[4]; }else if(Buffer_fullness < BufTh6) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[5])); MIN_QP = minQP[5]; MAX_QP = maxQP[5]; }else if(Buffer_fullness < BufTh7) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[6])); MIN_QP = minQP[6]; MAX_QP = maxQP[6]; }else if(Buffer_fullness < BufTh8) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[7])); MIN_QP = minQP[7]; MAX_QP = maxQP[7]; }else if(Buffer_fullness < BufTh9) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[8])); MIN_QP = minQP[8]; MAX_QP = maxQP[8]; }else if(Buffer_fullness < BufTh10) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[9])); MIN_QP = minQP[9]; MAX_QP = maxQP[9]; }else if(Buffer_fullness < BufTh11) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[10])); MIN_QP = minQP[10]; MAX_QP = maxQP[10];} else if(Buffer_fullness < BufTh12) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[11])); MIN_QP = minQP[11]; MAX_QP = maxQP[12];} else if(Buffer_fullness < BufTh13) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[12])); MIN_QP = minQP[12]; MAX_QP = maxQP[12];} else if(Buffer_fullness < BufTh14) { Target_activity_level = max(0,(MaxBitsPerGroup + offset[13])); MIN_QP = minQP[13]; MAX_QP = maxQP[13];} else { Target_activity_level = max(0, (MaxBitsPerGroup + offset[14]));MIN_QP = minQP[14]; MAX_QP = maxQP[14]; }

The 14 values of threshold (BufTh1 through 14) of buffer fullness inunits of bits may be set for a virtual buffer model size of 16 Kbits(16,384 bits) as {1792, 3584, 5376, 7168, 8960, 10752, 12544, 13440,14336, 15232, 15456, 15680, 15960, 16240}. The 15 values of offsets(offset[0 to 14]) for Target_activity_level may be set as {20, 10, 0,−2, −4, −4, −8, −10, −10, −10, −10, −12, −12, −12, −12}.

At any range of buffer fullness, which is bounded by two consecutivethresholds, e.g. BufTh1<=Buffer_fullness<BufTh2, there is a range ofQuant, specified by MIN_QP and MAX_QP, allowed for the rate controller208 to use. This helps to regulate the variation of Quant to avoidover-quantization when the buffer level is low, as well as avoiding theuse of too many less significant bits that may not help with visualquality when the buffer fullness is high. The pair of parameters, MIN_QPand MAX_QP, associated with each range of buffer fullness levels areselected respectively from an array of 15 values of minQP[0 to 14], withexample default values of {0, 0, 1, 2, 2, 3, 4, 8, 8, 8, 13, 14, 15, 16,17}, and an array of 15 values of maxQP[0 to 14] with example defaultvalues of {2, 2, 2, 3, 3, 7, 9, 10, 11, 12, 13, 14, 15, 16, 17},according to the buffer fullness level.

The value of Quant is adjusted according to the measured activitylevels, the target activity level, the allowed Quant range specified byMIN_QP and MAX_QP, and the strength of a strong edge. When there is astrong edge, the activity level normally increases significantly if thevalue of Quant stays fixed. The rate control algorithm detects thepresence of a strong edge by examining the activity level of the currentGroup and that of the preceding Group as well as the associated valuesof Quant. When a strong edge is detected, the rate control algorithmdoes not increase the value of Quant immediately after the presence ofthe strong edge, in order to avoid potential quantization noise that ismore readily visible in smooth areas that may follow a strong edge. Thisfactor may be observed for example in some cartoon content. The ratecontrol may increase the value of Quant at the second group after astrong edge. One parameter that serves as a threshold in detectingstrong edges is defined as EdgeFactor in the pseudo code below.

Some implementations avoid excessive fluctuation of Quant around a highquantization value, which could result in visible high frequencyquantization noise in some images. These implementations regulate theincrease of Quant so that Quant does not increase for two consecutiveGroups of pixels when the value of Quant is already high, with certainexceptions. However, the decrease of Quant may be allowed as soon as themeasured activity level is low. These adjustments are controlled by twoparameters defined as QuantIncrLimit[0] and QuantIncrLimit[1] in theexample below; their default values may be set to 11. In the followingexample, RcSizeGroup represents the activity level, BitsCodedCurrepresents the actual number of bits used to code the most recentlycoded Group, and RcTgtBitsGroup represents the Target_activity_level.RcTgtBitOffset[0] and RcTgtBitOffset[1] are offset values that adjustthe range of the target activity level. EdgeFactor is a parameter thatis used to detect a strong edge. The quantization step of the last Groupis Quant, which is saved as QuantPrev before it is assigned the valuefor the current Group.

The operation of the Quant adjustment may be implemented as follows:

if ( RcSizeGroup < (RcTgtBitsGroup − RcTgtBitOffset[0])  && BitsCodedCur< (RcTgtBitsGroup − RcTgtBitOffset[0])) { QuantPrev = Quant; Quant =MAX(MIN_QP, (Quant−1)); } else if (BitsCodedCur > RcTgtBitsGroup +RcTgtBitOffset[1]) { if ((QuantPrev == Quant && RcSizeGroup * 2 <RcSizeGroupPrev * EdgeFactor) || (QuantPrev < Quant && RcSizeGroup <RcSizeGroupPrev * EdgeFactor && Quant < QuantIncrLimit[0]) || (Quant <QuantIncrLimit[1] ) ) { QuantPrev = Quant; Quant = MIN(MAX_QP,(Quant+1));} } else QuantPrev = Quant;

When the buffer fullness approaches the maximum allowed level, the aboveQuant value determined by the activity level may be replaced by max_QP:

if (Buffer_fullness >= BufTh_overflow_avoid) *Quant = max_QP;

Where BufTh_overflow_avoid is a programmable parameter.

FIG. 8 shows an example decoder 800. The decoder 800 includes a ratebuffer 802, a variable length decoder (VLD) 804, a predictor, mapper andinverse quantizer (PMIQ) 806, and a rate controller 808. The decoder 800may be located in the same device or in a different device as theencoder, and may receive the bitstream input from any source, such as amemory or communication interface. For example, the decoder 800 may belocated remotely from the encoder and receive the input bitstream via anetwork interface.

The rate buffer 802 may be a FIFO memory which temporarily storescompressed data bits after the encoder 800 receives them. The ratebuffer 802 may be integrated with the rest of the video decoder or itmay be located in another module, and it may be combined with anothermemory. The size of the rate buffer 802 may be at least as large as thevirtual buffer used in the video encoder. For example, where the videoencoder uses a 16 kbits virtual buffer, e.g., 2048 bytes, the ratebuffer may be the same size, i.e., 2048 bytes or larger. Ready-acceptflow control may be used between the rate buffer 802 and the VLD 804 tocontrol that when the rate buffer 802 is empty the decoding operation issuspended until there is data available in the rate buffer 802.

The fullness of the rate buffer 802, at any given time, may not be thesame as the fullness of the virtual buffer model. In part this isbecause the decoder virtual buffer model mimics the operation of theencoder virtual buffer model, and not the operation of the decoder, andthe buffer model operates with the specified number of coded bits/pixeltimes the number of pixels in a Group being removed from the buffermodel every time a Group is decoded, rather than the actual schedule atwhich bits arrive at the decoder. The transmission of compressed bitsmay be modeled as being exactly synchronized with the decompressionfunction, while in actual operation the input of the rate buffer 802 maybe read from memory more quickly or more slowly than exactly this rate.This is one reason that the rate control, above, operates on the buffermodel and not on the rate buffer fullness.

The input to the VLD 804 is a compressed bit stream 812. The compressedbit stream 812 nay include a series of Groups. The Groups may include aset of Units. Each Unit may have a Prefix and some number of samples,for example two, three or four samples. The VLD 804 operation is theinverse of the variable length coder (VLC) 206 function. Since the inputto the VLD 804 is a stream of bits, e.g., a stream of VLC coded samples,part or all of the VLD operation may be performed sequentially. Some ofthe VLD functionality may be pipelined, however.

In one implementation, the VLD 804 uses a Unit size of 2, i.e., 2samples per Unit. The choice of Unit size may be the same for both theencoder and decoder for any given image. The Unit size is generally anattribute of the encoded bit stream.

The VLD 804 decoding operation entails determining the actual sizes(e.g., number of significant bits) of the samples in the previous Unitof the same component as the one currently being coded, and creating apredicted Unit sample size from this information. This analysis may bepipelined. The VLD 804 may decode the Prefix of each unit, which may beunary coded. The decoded Prefix value is added to the predicted samplesize value. The resulting sample size information indicates how manybits for each sample are contained in the Unit. The VLD 804 extractsfrom the incoming bit stream a number of bits equal to the prefix sizeplus the determined sample size times the number of samples per Unit.Once the VLD 804 extracts these bits, they are de-multiplexed andprocessed by subsequent decoding steps which may be pipelined.

Similar to the VLC, the number of bits spent for the current Group aswell as the activity level of the current Group are calculated andpassed to the rate controller 808 for rate control. The VLD 804generates the values of RcSizeGroup and BitsCodedCur and passes these tothe rate controller 808.

Once the coded samples are extracted, they are converted to a suitableformat for subsequent processing. For example, they may be converted toan 11 bit 2's complement signed format, with sign-extension of negativesample values. These constant-width sample values are demultiplexed intoindividual component streams of samples, and sent to the Predictor,Mapping and I-Quant (PMIQ) block 806.

FIG. 9 shows example logic 900 for encoding. The logic 900 initializesthe quantization step to zero (902) and receives a unit of pixelcomponents (904). The logic 900 also performs quantization using thequantization step and encodes the quantized values (906). The logic 900measures the fullness of the virtual buffer (908) and adjusts thequantization step based on the measured fullness (910). If the encodingis finished (912), flow may return to (902) or terminate altogether;otherwise flow may continue at (904).

FIG. 10 shows example logic 1000 for decoding. The logic 1000initializes the quantization step to zero (1002). The logic 1000 decodesa coded unit and updates the virtual buffer (1004). The logic 1000 alsodequantizes using the quantization step parameter (1006), and measuresthe fullness of the virtual buffer (1008). Further, the logic 1000 mayadjust the quantization step based on the measured fullness (1010). Thelogic 1000 determines whether decoding of the frame is finished (1012),and if so, flow may return to (1002) or terminate. Otherwise, the flowmay return to (1004).

Operation Description

The description above provides an example architecture that supportsadditional specific image processing operations. An introduction to someof these operations is provided next. Additional architecturalimplementations that support the image processing operations are alsodiscussed further below.

FIG. 11 shows an example encoding and decoding system 1100, based on theexample of FIG. 1. The system 1100 supports real time operation. Sourcedata 112, which may be uncompressed, enters the encoder 104, for examplein real time and raster scan order. The encoder 104 compresses incomingpixels to form a bitstream and temporarily stores portions of thebitstream in its rate buffer 210. The output of the rate buffer 210 isthe slice layer of a Display Stream Compression (DSC) bitstream 1106.The DSC bitstream 1106 may be conveyed, e.g., in real time from theencoder 104 to the decoder 106. In that regard, a wide variety ofcommunication links 1104 may convey the DSC bitstream 1106 to thedecoder 106. Underlying the communication links 1104 may be a widevariety of transport layers, and the communication links 1104 mayinclude local high speed busses, WiFi links, Ethernet links, satellitelinks, cellular (e.g., 3G or 4G/LTE) links, as examples.

The decoder 106 receives the DSC bitstream 1106 into its rate buffer802, which temporarily stores portions of the DSC bitstream 1106. Thedecoder 802 decodes bits from the rate buffer 802 to obtain uncompressedpixels. The decoder 802 outputs the uncompressed pixels, e.g., in realtime and in raster scan order, for the display 110. The image outputfrom the decoding process may have the same format as the image input tothe encoding process.

The DSC bitstream may include of a sequence of frames coded using apicture layer syntax. The picture layer syntax may include a PPS(picture parameter set) and a slice syntax. The PPS contains parametersthat the decoder 106 uses for correct decoding of the slice layer. FIG.12 shows an example of a PPS 1200.

The picture layer may operate in units of entire pictures. A picture maybe, as examples, a frame in the case of a progressive format video, or afield in the case of an interlaced format video. Each picture mayinclude an integer number of contiguous, non-overlapping,identically-sized, rectangular slices. In the encoder 104, slice codingis specified via a slice layer. In the decoder 106, each slice may bedecoded independently without reference to other slices. There may beone slice per line or multiple slices per line. In the case of multipleslices per line, bits from the slices covering one line are multiplexedin the DSC bitstream 1106 via a slice multiplexing process describedbelow. Each slice may include a set of groups, and each group may be aset of three consecutive pixels in raster scan order. Further, theencoder 104 may encode each group with multiple (e.g., three) entropycodes, one for each component, and each of which may be a specific typeof variable length code (VLC). Furthermore, some groups may include oneor more additional bits which signal specific decoding operations.

FIG. 13 shows another example of an encoder 1300. The DSC encodingprocess generates bitstreams that may precisely conform to theindependently specified bpp (bits per pixel) rate. The bpp rate may bespecified in terms of bits per pixel time, which may be algorithmicallyspecified, as the unit of a pixel time is the same at both the input andoutput of the encoder 1300. The number of bits that code each pixel, orgroup of pixels, may vary considerably. In the encoder 1300, the ratebuffer 1302 facilitates converting the variable number of bits used tocode each group into, e.g., a constant bpp rate. To that end, theencoding process includes the rate controller 1304.

The encoder 1300 may include color space conversion logic 1306, e.g.,RGB input to reversible YCoCg conversion logic. An input buffer 1308stores the converted input. Prediction, quantization, and reconstruction(PQR) logic 1310 implements prediction of sample values and generationof residual values. The prediction, quantization, and reconstruction(PQR) logic 1310 may include multiple (e.g., three) predictors: modifiedmedian adaptive prediction (MMAP), mid-point prediction (MPP), and blockprediction (BP). The PQR logic 1310 also implements quantization ofresidual values and reconstruction of sample values. An indexed colorhistory (ICH) 1312 is also present, as is VLC coding logic 1314 that mayimplement entropy coding using delta size unit variable-length coding(DSU-VLC). The input buffer 1308 provide samples to the flatnessdetermination logic 1318. Note also that substream multiplexing logic1320 is present to prepare a multiplexed output stream to the ratebuffer 1302.

FIG. 14 shows another example of a decoder 1400 configured to decodeimage data that the encoder 1300 has encoded, and produce image output1418. The decoder 1400 may implement the inverse of the operations thatwere performed by the encoder 1300. The decoder 1400 may include a ratebuffer 1402, substream demultiplexer 1420, and VLC entropy decodinglogic 1404 for delta sized unit variable length coding (DSU-VLC). Thedecoder 1400 also includes PQR logic 1406 that may implement multiple(e.g., three) predictors: modified median adaptive prediction (MMAP),mid-point prediction (MPP), and block prediction (BP). The PQR logic1406 also performs inverse quantization of residual values andreconstruction of sample values. An ICH 1408, rate control logic 1410,and color space conversion logic 1412 is also present. Flatnessindications may be signaled in the bitstream from the encoder, andprovided to the rate control logic 1410.

The encoding process may produce display stream coded bitstreams thatconform to an HRD (hypothetical reference decoder) constraint. The HRDmay be idealized model of a decoder that includes a model of a ratebuffer, which should neither overflow nor underflow.

The DSC bitstream and decoding process facilitate decoding 3 pixels perclock cycle in practical hardware implementations. In otherimplementations, the decoding process may process 1, 3, or other numbersof pixels per clock. Additional throughput in terms of pixels per clockmay be increased via encoding and decoding multiple slices in parallel,which is facilitated by utilizing multiple slices per line in the DSCbitstream.

Color Space Conversion Logic 1306, 1412

RGB video input to the encoding process may be converted to YCoCg forsubsequent processing. The reversible form of YCoCg may be used, and assuch the number of bits per each of the two chroma components is onegreater in YCoCg than it is in RGB. In the case of YCbCr input, no colorspace conversion need be performed. The inverse color space conversionis performed in the decoding process.

PQR Logic 1319, 1406

Each group of pixels is coded using either predictive coding (P-mode) orindexed color history coding (ICH-mode). For P-mode there are threepredictors: modified median-adaptive prediction (MMAP), block prediction(BP), and midpoint prediction (MPP). The encoder and decoder may selectMMAP, BP, or MPP automatically, using the same algorithm in each,without signaling the selection in the DSC bitstream.

In the encoder 1300, each sample is predicted using the selectedpredictor. The original sample value is compared to the predicted value,and the difference is quantized. Each quantized error is thenentropy-coded if P-mode is selected. The encoder 1300 also performs areconstruction step wherein the inverse-quantized error is added to theprediction so that the encoder and decoder may use the same referencesamples.

In decoder 1400, the samples are predicted using a selected predictor.The residual value, which is obtained from decoding the DSC bitstream,is inverse quantized and the result added to the prediction, forming thereconstructed sample value.

The median-adaptive predictor (MAP) may be the prediction method that isused in JPEG-LS. However, a modification is made to allow the decoder1400 to process three pixels in a group in parallel and to improvecoding. The modified median-adaptive predictor (MMAP) facilitateshardware implementations for decoders running at 3 pixels/clock. TheMMAP predicts a current sample value as a function of reconstructedpreviously coded samples to the left and above the current sample. Theencoder 1300 and decoder 1400 may use identical sets of reconstructedsamples for this purpose, and hence the MMAP produces the same resultsin both the encoder 1300 and the decoder 1400. MMAP may be the defaultpredictor, and is effective at predicting sample values in mostconditions.

The MPP predicts a current sample from a value that is approximately atthe mid-point of the valid range for the sample. The MPP has the benefitof bounding the maximum size of the residual. MPP may be selected inplace of MMAP when the number of bits required to code the samples in ofone component of a group would be greater than or equal to the bit depthfor that component minus the quantization shift.

The BP predicts a current sample from a reconstructed previously codedsample to the left of the current sample in the same scan line. Theoffset from the current sample to the predictor position is a BP vector.The BP vector and the decision of whether or not to use BP aredetermined automatically by the BP function, which is the same in boththe encoder and decoder.

Block Prediction

Block prediction may predict the current sample where the predictor is asample to the left of the current sample, in the same line. The relativeposition of the reference sample may be between (−3) and (−10),inclusive. Using additional pixel locations may improve quality. Therelative position is a vector within the same line of samples; this isreferred to as the block prediction vector.

The search to find the best vector may be performed on the previous lineof samples, rather than the line that is currently being coded. In oneimplementation, the block search compares a set of 9 consecutive sampleswith reference samples using various potential vectors with valuesranging from −3 to −10. The current samples and the reference samplesbeing compared are in the same scan line, e.g., the line above the lineof the sample to be coded. For each vector considered, a SAD (sum ofabsolute differences) is calculated over 9 samples in each of thecurrent and reference set. The vector with the lowest SAD value isselected. In cases of ties, the vector closest to 0 is selected.

The 9-pixel SAD of the vector −1 is also used in order to determinewhether BP or MMAP should be used. More details of predictor selectionare given below.

A vector, once selected, applies to each group of 3 samples. Thereforethe block search is performed every 3 samples.

A vector means that the predictor for pixel X is the pixel that is tothe left of pixel X in same line, the distance to the left in pixelunits being equal to the vector value.

FIG. 15 illustrates example sample sets 1500 for block search, showingseveral reference samples 1502 and vectors 1504, 1506. An example of thecurrent sample ‘x’ 1506 and the current SAD calculation samples 1508 arealso shown.

Indexed Color History (ICH) Logic 1312, 1408

FIG. 16 illustrates an example of indexed color history 1600.

In many types of content, such as computer-generated text and graphics,similar pixel values tend to appear in reasonably close proximity whilenot necessarily being adjacent to one another. Because of this, it canbe helpful to keep track of a number of recently-used pixel values inthe Indexed Color History (ICH). When the encoder 1300 selects ICH-modefor a particular group, it sends index values corresponding to theselected pixel values within the ICH. These index values are useddirectly in the output pixel stream.

The ICH logic includes a storage unit that maintains a set of recentlyused color values that were coded using another coding method such aspredictive coding. The encoder 1300 and decoder 1400 may maintainidentical states of the ICH. The ICH may have 32 entries, with an indexvalue pointing to each entry. For groups that are ICH coded, each pixelmay be coded with a 5-bit ICH index, which points to one of the entries.As each group of pixels is encoded in the encoder or decoded in thedecoder in P-mode, the values of all the pixels in the group are enteredinto the ICH. The ICH may be managed as a shift register where themost-recently used (MRU) values are at the top and the least-recentlyused (LRU) values are at the bottom. New entries are added at the topand all other entries are shifted down, with the bottom entries fallingout of the ICH. When a group is coded in ICH-mode, the three indicesused to code those pixels reference entries in the ICH. When an ICHentry is referenced, it is moved to the top of the ICH and the othervalues above the prior location of the entry are shifted down by 1. Thisoperation is performed in parallel for all 3 entries of each ICH codedgroup, and the most recent, e.g., the rightmost pixel value of the groupbecomes the MRU. The result is that the most recently used (MRU) valueis at the top of the history and the least recently used (LRU) value isat the bottom of the history. Whenever a P-mode group of three pixels isadded at top of the history, the three LRU values are removed.

For the first line each slice, all 32 ICH entries are treated as part ofthe shift register. For lines after the first line of a slice, the last7 index values are defined to point to reconstructed pixels in the lineabove the current line, rather than entries in the ICH. This is usefulfor efficient coding of pixel values that are not in the history shiftregister, and it improves coding with some content.

ICH mode may be selected on a per-group basis by the encoder 1300. Theencoder 1300 signals the use of ICH mode for a group using an escapecode in the luma substream DSU-VLC. For each group coded in ICH mode,each pixel in the group is coded using a fixed-length 5 bit code, wherethe index values point into the history. The decoder 1400 decodes eachICH-coded group by determining the use of ICH mode via the bitstreamsyntax and decoding each pixel in the group by reading the valuespointed to by the ICH indices that constitute the coded values of thepixels. Both the encoder 1300 and decoder 1400 update the ICH stateidentically every group by inserting P-mode pixels into the ICH and byre-ordering the ICH entries in response to ICH mode groups.

Entropy Coding Logic 1314, 1404

The display stream coding defines syntax at multiple layers. The lowestlayer is called the substream layer. There may be three substreams ineach slice, one for each component. The three substreams may bemultiplexed together by a substream multiplexing (SSM) process to form acoded slice. If there is more than one slice per line, the coded slicesmay be multiplexed by the slice multiplex process; and if there is onlyone slice per line, the slice multiplex process is not used. Theresulting bits of all slices are concatenated to form a coded picture.Each coded picture is optionally preceded by a picture parameter set(PPS).

Substream Layer

The display stream encoding may use an entropy coding technique referredto above as DSU-VLC for coding residuals associated with predictivecoding. ICH coding of pixels uses a fixed-length code for each pixel.Specialized values are used to signal the use of ICH mode, and othercodes signal quantization adjustments associated with flat regions ofpixels.

TABLE 1 Examples of sizes for different residual values Residual valuesSize in bits Representation −3 3 101b −2 2  10b −1 1  1b 0 0 <none> 1 2 01b 2 3 010b 3 3 011b

The pixels in each slice may be organized into groups of threeconsecutive pixels each. A group is a logical construction employed bythe encoding and decoding processes, but need not be directlyrepresented in the bitstream. DSU-VLC organizes samples into units. Aunit is the coded set of residuals of three consecutive samples of onecomponent. Each unit has two parts: a prefix and a residual. The size ofeach residual is predicted based on the size of the three previousresiduals of the same component type and any change in QP that may haveoccurred. The prefix may be a unary code that indicates the non-negativedifference between the size of the largest residual in the unit and thepredicted size. If the difference is negative, the value coded by theprefix is zero. The residual portion of each unit contains 3 values, onefor each sample in the unit. The residual values are coded in 2'scomplement. The number of bits allocated to residuals can vary from unitto unit; however, all 3 residuals in one unit may be allocated the samenumber of bits.

In addition, the prefix for luma units also indicates whether or not ICHmode is used for each group. A transition from P-mode to ICH-mode may beindicated by an escape code, e.g., a prefix value that indicates a sizethat is one greater than the maximum possible residual size for luma.The maximum possible residual size for luma depends on the QP value thatapplies to luma in the group. An ICH-mode group immediately followinganother ICH mode group may be indicated by a luma prefix code consistingof a single “1” bit. A P-mode group immediately following an ICH-modegroup may be indicated by a modified unary code.

For an ICH-mode group, the residual portion may be 5 bits for eachcomponent, where each 5 bit code is an ICH index which codes a completepixel, and the chroma components do not utilize a prefix. For subsequentICH-mode groups following an initial ICH-mode group, each group may use16 bits for every group, e.g., a 1 bit prefix and (3) 5 bit ICH codes.

The luma substream may also contain some conditional fixed-length codesin the syntax for the purpose of the encoder conveying information abouta transition from a busy area to a smooth area. This “flatnessindication” is discussed in more detail below.

Substream Multiplexing

The three component-wise substreams may be multiplexed together using afixed-length substream multiplexing scheme with no headers. Onetechnique for doing so is described in the U.S. Patent PublicationNumber 2011-0305282 A1, which is incorporated by reference. Error!Reference source not found. FIG. 17 shows an example of the results ofsubstream multiplexing 1700, including various multiplexed words andcomponents 1702. Each mux word may have an identical size, e.g., 48 bitsfor 8 or 10 bits per component (bpc), or 64 bits for 12 bpc. The orderof the mux words 1702 is derived from the order in which parallelsubstream decoders use the data in order to decode in real time.

FIG. 18 shows an example of substream demultiplexing logic 1800. Thelogic 1800 includes a memory such as a rate buffer 1802, a demultiplexer1804, and funnel shifters with VLD 1806, 1808, and 1810. The combinationof the funnel shifter and VLD is referred to as a substream processor(SSP). At each group time, any combination of the SSP's may request amux word or none at all. If a request is received from an SSP, thedemultiplexer 1804 sends a mux word to that SSP. If multiple requestsare received in the same group time, the demultiplexer 1804 sends a muxword to each SSP that made a request.

At the end of the slice, the SSP's may request mux words beyond the endof the substream layer data. Therefore, the encoder 1300 may insertpadding mux words as needed at the end of the slice.

FIG. 19 shows an example of the substream multiplexing logic 1900,including VLC and funnel shifters 1902, 1904, 1906, balance memories(e.g., FIFOs) 1908, 1910, 1912, a multiplexer 1914, rate buffer 1916,and demultiplexer model 1918. The demultiplexer model 1918 helps theencoder 1300 to order the mux words correctly. The balance FIFO's 1908,1910, 1912 may store many groups worth of data in order to provide themux words at the appropriate time.

Rate Control

The encoder 1300 and decoder 1400 may use identical rate control (RC)algorithms, configured identically. The decisions made by the RCalgorithm to adjust QP in the encoder are mimicked in the decoder 1400,such that the decoder 1400 has the same QP value as the encoder 1300 atevery pixel, without any bits being spent communicating the QP value,except for the flatness indication. RC decisions are made in the encoder1300 and decoder 1400 based on information previously transmitted andreceived. RC can change the QP value every group.

Rate Control Goals

The RC provides the encoder 1300 and decoder 1400 with quantizationparameters (QP) to use for each group. Since the RC function is the sameon both the encoder side and the decoder side, the base QP value isknown to both encoder 1300 and decoder 1400, and it does not need to betransmitted in the bitstream. However, the base QP value or adjustmentsto the QP value may be sent in the bitstream for flatness indication,described below.

The RC attempts to ensure hypothetical reference decoder (HRD)conformance. There is a model of an idealized rate buffer (FIFO) thatconverts a varying number of bits to code each group into a specifiedconstant bit rate. The RC is designed to ensure that this FIFO will notoverflow or underflow assuming that bits are removed at an assumedconstant bit rate.

The RC optimizes picture quality in its QP decisions. It is desirable touse a lower QP on relatively flat areas and a higher QP on busy areasdue to perceptual masking. In addition, it is desirable to maintain aconstant quality for all pixels; for example, the first line of a slicehas limited prediction, and may therefore use an additional bitallocation.

HRD Buffer Model

A hypothetical reference decoder (HRD) model describes the behavior ofan idealized rate buffer in a decoding system. An encoder rate buffermodel may be mirrored on the decoder side. The encoder model tries toensure that there are no overflows or underflows. Since the DSC may beconstant bit rate (CBR), the HRD model fullness is equal to buffersize−encoder buffer fullness; therefore, the decoder buffer model doesnot overflow or underflow. The DSC encoder rate buffer model may definea schedule for bits entering and leaving the rate buffer.

During the initial delay, e.g., initial transmission delay, the encodergenerates bits into its rate buffer every group, but no bits areremoved. During this period, the encoder model fullness increasesaccording to the number of bits that are generated. The delay period maybe specified in terms of group times or pixel times, as examples.

As long as there are more pixels in the slice to be encoded, the encodergenerates bits according to the content. Bits are removed at theconstant rate that is specified. To prevent the buffer fullness fromdropping below 0, the prediction mode may be overridden to use MPP,which enforces a minimum data rate. Once the last group of a slice hasbeen encoded, no more bits are added to the rate buffer. Bits continueto leave the rate buffer at the constant rate until the buffer becomesempty, after which the encoder sends zero bits to ensure that thecompressed slice size in bits is equal to bpp*number of pixels in slice,in CBR operation.

The decoder initial delay is specified as the complement of the encoderinitial delay; e.g., the HRD delay minus encoder initial delay. Thedecoder rate buffer fullness then tracks as the complement of theencoder buffer fullness.

CBR vs. VBR

Under conditions when the encoder rate buffer would otherwise underflow,there is a design choice of whether the encoder inserts bits to preventunderflow, or it uses VBR. To prevent underflow, the RC determineswhether underflow is possible after the next coded group, and when thiscondition occurs it forces MPP mode which enforces a minimum bit rate.The decoder does not require any special logic to handle stuffing, as itdecodes the extra bits just as it would any other group.

It is possible to support variable bit rate (VBR). With VBR, the encoder1300 stops sending bits under certain conditions when it would otherwiseunderflow and has no bits to send (Off). The encoder 1300 then startssending bits again at some identified event (On). To make on-off VBRcompatible with a general HRD that does not depend on the real timebehavior of the transport, the off and on events may be specified.

With VBR, the encoder stops sending bits when it would otherwiseunderflow and has no bits to send. The encoder's RC process operatesonce per group. At each group, it adds to the buffer model the number ofbits that code the group, and normally it subtracts from the buffermodel the nominal number of bits per group, which is 3*bpp, adjusted asnecessary to form an integer number of bits. With VBR, if thissubtraction of bits/group from the buffer model fullness would result ina negative value of fullness, the RC subtracts the normal number of bitsand then clamps the buffer fullness to zero, i.e. the model fullness isnever allowed to be negative. In a real system with a real transport andreal decoder, when the encoder has no bits to send, i.e. its real ratebuffer is empty, the transport does not send any bits and the decoderdoes not receive any bits. The decoder's real rate buffer may be full,but it does not overflow. When the encoder does have bits to send,transport is expected to transmit them at the normal rate and thedecoder receives them at that rate. The decoder's real buffer does notoverflow nor underflow, and the decoder does not have to do anythingspecial to handle VBR. The transport should understand when there is andis not valid data available to send and receive.

Slices

The number of bits that code a picture may be equal to the number ofpixels of that picture times the specified bpp rate. Further, any subsetof slices of a picture may be updated in place in a compressed framebuffer by over-writing the previous version of each of the correspondingslices. One consequence is that a complete picture can be transmitted asa series of consecutive slices comprising the entire picture, and thatan entire picture transmitted as a series of consecutive slices meetsthe same requirement as for slices, e.g., the number of bits equals thenumber of pixels times the bpp rate, and also the entire picturecomprising slices should conform to an appropriate HRD model to ensurecorrect real time buffer behavior with this mode of operation. Oneconsequence is that the delay from the start of transmission to thestart of decoding and the delay from the end of transmission to the endof decoding are the same as one another and the same for each slice.

The algorithm uses a rate buffer model, which may be referred to as arate buffer. The algorithm allows the encoder's rate buffer to have upto a specified fullness, e.g., a maximum number of bits, at the end ofeach slice. If at the end of coding a slice the encoder's buffer hasfewer bits than this maximum number, it may pad the remaining bits atthe end with 0s, for example, to produce exactly the required number ofbits. This final number of bits occupies a specified number of pixeltimes to transmit at the specified bpp rate. This number of pixel timesis the delay from the end of encoding to the end of transmission, whichmay be called the final transmission delay. The total rate buffer delay,in units of pixel times, in the combination of an idealized encoder anddecoder is equal to the rate buffer size divided by the bpp rate. Theinitial transmission delay, from the start of encoding a slice until thestart of transmission of that slice, is the same as the finaltransmission delay. The initial decoding delay, e.g., the delay in theHRD timing model from the start of reception of a slice to the start ofdecoding of the slice is set equal to the total end-end rate bufferdelay minus the initial transmission delay. This permits correctoperation per the description above.

FIG. 20 shows an example of slice timing and delays 2000. FIG. 20 showsslice input video timing 2002, slice transmission timing 2004, and slicedecoding timing 2006. The algorithm may have a fixed parameter value forthe maximum number of bits that can be in the encoder buffer at the endof a slice, typically ˜4 kbits. The resulting ending transmission delayis a function of the bpp rate; it is set to ceiling(4096/bpp_rate). At 8bpp, this delay is 170 group times, and at 12 bpp it is 114 group times.The initial delay may be set to this value.

The end-end HRD delay is equal to the HRD buffer size divided by the bpprate. For example, if the HRD buffer size is 19,836 bits and the rate is12 bpp, the end-end HRD delay is floor(19,836/36)=551 group times. Thisis actually an upper bound, and the HRD delay could be set to a lowervalue, however if a lower value were used then the algorithm would notbe able to take full advantage of the available buffer size for purposesof RC.

The initial decoding delay, which applies directly to the HRD andindirectly to real decoders, should be set to the HRD delay-initialtransmission delay. In the example here, where the initial transmissiondelay is set to 114 group times as above, the initial decoder delay is551−114=437 group times. This is a delay that applies to the HRD, i.e.an idealized hypothetical decoder. A real decoder is of course free tohave additional delay.

The algorithm's rate buffer size, which is also the HRD buffer size, canbe selected by an encoder as long as it does not exceed the capabilitiesof compatible decoders. The optimum rate buffer size is a function ofseveral factors including the bpp rate and the width of slices.

Note that the initial transmission delay is typically a function of bpprate. The HRD rate buffer size may be set by the encoder as long as itdoes not exceed the capabilities of decoders. It is practical to designreal systems with adjustable bit rate and constant end-end delay, fromvideo into the encoder to video out of the decoder, and with constantdelay from compressed data into the decoder to video put of the decoder.An encoder may set the initial transmission delay and the initialdecoder delay to selected values to facilitate seamless changes of bitrate with constant delay.

Options for Slices

The encoder 1300 and decoder 1400 support a wide variety of slice widthsand heights. One configuration is slice width=¼picture width and sliceheight=32 lines. Another possible configuration is slice width=picturewidth and slice height=8 lines. The slice dimensions can be specified upto the picture width by the picture height. To minimize extra data thatmay need to be sent, equal-sized slices may be used throughout thepicture.

Taller slices may lead to better compression. Extra bits are allocatedto the first line of each slice to maximize quality and to preventartifacts at the boundaries between slices. The number of extra bitsallocated per group on the first line is set via a parameter in the PPS.The numbers of bits available to all lines after the first line eachslice may be reduced in order that the total number of bits per slice isthe number of pixels times the bpp rate. The more lines there are afterthe first line in each slice, the less reduction in bit allocation isrequired. Therefore a slice height of 32 lines typically gives betterperformance than a slice height of 8. There is no cost associated withslice height—there is no additional buffering nor any other additionalresources. The encoder 1300 and decoder 1400 support a slice size equalto the entire picture size.

Slices narrower than the full screen width may be desirable for variouspractical purposes. Narrower slices provide the ability to update, viapartial update, a narrower slice, or to facilitate parallel processingat low cost. In practice, multiple slices per line can use one linebuffer the size of the picture width. With multiple slices per line, andslices that are taller than one line, the rate buffers for the differentslices may be independent. For example, with four slices per line, apractical implementation would use four rate buffers. The sizes of eachrate buffer can be specified to be smaller for the case of 4 slices/linethan they would normally be specified for the case of one slice/line, asthe optimum rate buffer size is a function of the slice width, althoughnot exactly proportional. Hence there is a small increase in the totalamount of rate buffer space when there are multiple slices per line,while there is no increase in the total amount of line buffer space.

Slice Multiplexing

In systems configured to use more than one slice per scan line, thecompressed data may be multiplexed according to a specific pattern inorder to minimize cost in both encoders and decoders. The recommendedpattern is as follows. For an integer number S of slices per line, eachslice has P pixels per line, and the picture is W pixels wide.Preferably P is equal for all slices, equal to W/S, which is preferablyan integer. The multiplexed bit stream contains a number of bits=P*bpprate for the first slice of the first row of slices, then P*bpp rate forthe 2nd slice of the first row, and so on for all slices of the firstrow.

One iteration of this pattern has W*bpp rate bits, which may be the samenumber of bits as would have been used if there were one slice per line.If P*bpp rate is not an integer, an adjustment can be made to result inan integer number of bits per slice. For example, the number of bitsincluded for one line of one slice may be the integer truncated value ofP*bpp plus the accumulated residual amount from previous truncations.Then this pattern repeats as many times as needed to transmit all thebits of all slices in the first row of slices. An applicationspecification, for example a transport specification that is designed tocarry DSC compressed image data, may carry data from different slices inseparate packets. In that case, the last bits from one slice may be in aseparate packet from those of other slices, including the first bits ofthe vertically adjacent slice immediately below the first one.Alternatively an application specification may choose to package thelast bits of one slice with the first bits of another slice, for examplea horizontally adjacent neighboring slice or a vertically adjacentneighboring slice. The overall pattern may repeat for the entire image.It is not necessary to include markers or other indications in the bitstream indicating which bits are for which slice. Instead, the transportlayer may provide such indicators.

Additional Information on Slice Multiplexing Follows.

Slice multiplexing may occur when VBR is disabled, e.g., stuffing isenabled. When stuffing is disabled, the number of bits coding each slicemay vary, e.g., the DSC operation is VBR. Pictures include some numberof slices. Slices may be identically-sized when possible, e.g., when theratio of picture width to slice width is an integer. In case this ratiois not an integer, the widths of the columns of slices may be set tointeger values that differ by no more than 1, and whose sum is thepicture width. Slice multiplexing is possible also when VBR is enabledas well. The memories used and multiplexing pattern will depend oncharacteristics of the link, including for example, the overheadrequired to enter or leave a low-power state.

With VBR disabled (stuffing enabled) slices of the same width are codedusing the same number of compressed bits. When the slice width is equalto the picture width, the slice layer data is sent sequentially (slice0, slice 1, . . . , slice N−1, where N is the number of slices). Whenthe slice width is shorter than the picture width, the slice data forall slices on the same line may be multiplexed into fixed-length chunks.The length of each chunk may be equal tofloor(bits_per_pixel*slice_width). The floor( ) function is used sincebits_per_pixel may be fractional. For example, in a case where thepicture is split into two equal-sized slices on each line, themultiplexed bitstream would contain:

Slice 0 chunk/Slice 1 chunk/Slice 0 chunk/Slice 1 chunk . . . .

The final chunks of each slice may be padded with zero bits if neededdue to the ceil( ) function.

With VBR enabled, the number of bits of coding each slice may differfrom P*bpp rate. For example, the number of bits may be less than thisvalue. The number of bits per chunk may differ fromfloor(bits_per_pixel*slice_width), for example the number of bits may beless than this value. Slices may be multiplexed using chunks of unequalnumbers of bits. The numbers of bits per chunk may be indicated forexample by packet length information or marker codes in a transportlayer.

The display stream coding may be specified in terms of components thatare labeled Y, Co, and Cg. If the convert_rgb flag is equal to 0 in thecurrent PPS, the encoder may accept YCbCr input. The Cb component may bemapped to the Co component label. The Cr component may be mapped to theCg component label. In this case, the bit depth of the Cb/Co and Cr/Cgcomponents may be equal to the Y component, whose bit depth is specifiedusing the bits_per_component field in the current PPS. If theconvert_rgb flag is equal to 1 in the current PPS, the encoder mayperform color-space conversion from RGB to YCoCg. The color spaceconversion may be:

-   cscCo=R−B-   t=B+(cscCo>>1)-   cscCg=G−t-   y=t+(cscCg>>1)

The cscCo and cscCg values have one additional bit of dynamic rangecompared with Y. The final Co and Cg values may be centered around themidpoint:

-   Co=cscCo+(1>>bits_per_component)-   Cg=cscCg+(1>>bits_per_component)

Note that here, the bits_per_component variable may represent the numberof bits of each of the R, G, and B components, which is one less thanthe number of bits per component for the Co and Cg components. If aslice extends beyond the right edge of a picture, the right-most pixelin each line of the picture may be repeated to pad the slice to thecorrect horizontal size. If a slice extends beyond the bottom edge of apicture, the bottom-most pixel in each pixel column of the picture maybe repeated to pad the slice to the correct vertical size.

Line Storage

The display stream compression may include buffer memory to hold theprevious line's reconstructed pixel values for MMAP prediction and ICH.In some cases, a decoder line buffer may have sufficient storage tocontain the full-range reconstructed samples. However, some decoders maychoose to use a smaller bit depth to lower the implementation cost.

If a smaller bit depth is used, the decoder may communicate this to theencoder. The encoder may set the linebuf_width according to what thedecoder implementation supports. The following method for bit-reducingsamples may be used:

-   shiftAmount=MAX(0, maxBpc−linebuf_width);-   round=(shiftAmount>0)?(1<<(shiftAmount−1)): 0;-   storedSample=(sample+round)<<shiftAmount;-   readSample=storedSample<<shiftAmount;

where maxBpc is the bit depth of the current component, storedSample isthe sample value that is written to the line buffer, and readSample isthe value that is read back.

Prediction Types

There are three prediction types that may be supported in P-mode: MMAP,BP, and MPP.

Modified Median-Adaptive Prediction (MMAP)

The modified median-adaptive predictor is specified in the table below.

TABLE 2 Pixels surrounding current group c b d e a P0 P1 P2

Table 2 shows the labeling convention for the pixels surrounding thethree pixels in the group being predicted (P0, P1, and P2). Pixels ‘c’,‘b’, ‘d’, and ‘e’ are from the previous line, and pixel ‘a’ is thereconstructed pixel immediately to the left.

A QP-adaptive filter may be applied to reference pixels from theprevious line before they are used in the MMAP formulas below. Ahorizontal low-pass filter [0.25 0.5 0.25] may be applied to theprevious line to get filtered pixels filtC, filtB, filtD, and filtE. Forexample,

-   -   filtB=(c+2*b+d+2)>>2;

The filtered pixels may be blended with the original pixels to get thevalues that are used in MMAP (blendC, blendB, blendD, blendE). Thefollowing method is used for the blending:

-   -   diffC=CLAMP(filtC−c, −QuantDivisor[qlevel]/2,        QuantDivisor[qlevel]/2);    -   blendC=c+diffC;    -   diffB=CLAMP(filtB−b, −QuantDivisor[qlevel]/2,        QuantDivisor[qlevel]/2);    -   blendB=b+diffB;    -   diffD=CLAMP(filtD−d, −QuantDivisor[qlevel]/2,        QuantDivisor[qlevel]/2);    -   blendD=d+diffD;    -   diffE=CLAMP(filtE−e, −QuantDivisor[qlevel]/2,        QuantDivisor[qlevel]/2);    -   blendE=e+diffE;

The predicted value for each is given below:

-   -   P0=CLAMP(a+blendB−blendC, MIN(a, blendB), MAX(a, blendB));    -   P1=CLAMP(a+blendD−blendC+R0, MIN(a, blendB, blendD), MAX(a,        blendB, blendD));    -   P2=CLAMP(a+blendE−blendC+R0+R1, MIN(a, blendB, blendD, blendE),        MAX(a, blendB, blendD, blendE));

where R0 and R1 are the inverse quantized residuals for the first andsecond samples in the group.

In the case of the first line of a slice, the previous line's pixels arenot available. So the prediction for each pixel becomes:

-   -   P0=a;    -   P1=CLAMP (a+R0, 0, (1<<maxBpc)−1);    -   P2=CLAMP (a+R0+R1, 0, (1<<maxBpc)−1);

where maxBpc is the bit depth for the component that is being predicted.

Block Prediction (BP)

The BP predictor is a pixel value taken from a pixel some number ofpixels to the left of the current pixel. The “block prediction vector”(bpVector) is a negative value that represents the number of pixels tothe left to use for the prediction. In one implementation, the blockprediction vector is always between −3 and −10 inclusive, which meansthat it uses samples outside of the current group.

The BP predictor is used to predict all three components from the pixelreferred to by the block prediction vector:

-   -   P[hPos]=recon[hPos+bpVector];

So the predicted values for the 3×1 group correspond with thereconstructed pixels values for the 3×1 set of pixels that is pointed toby the block prediction vector.

Midpoint Prediction

The midpoint predictor is a value at or near the midpoint of the range,and depends on the value of the reconstructed pixel immediately to theleft of the current pixel (pixel “a” in Table 2).

midpointPred=(1<<(maxBpc−1))+(a&((1<<qLevel)−1));

where maxBpc is the bit depth for the component being predicted, andqLevel is the quantization level that applies to the current component.

Predictor Selection

Block prediction is supported by the encoder 1300. The encoder 1300 maychoose to disable block prediction in the stream (e.g., because theattached decoder does not support block prediction or because thepicture would not benefit from block prediction) by settingblock_pred_enable in the PPS equal to 0. In this case, MMAP is selectedover block prediction, and the algorithms in this section are not used.

The decision to use either BP or MMAP may be made on a group basis usinginformation from the previous line. This means that the decision can bemade up to a line time in advance of processing the current group if ithelps the implementation. The group referred to in this section startsat a horizontal location of hPos pixels from the leftmost pixel columnin the slice.

FIG. 21 shows an example 2100 of 3×1 partial SADs that form 9×1 SAD.First, a search may be performed to find the best block predictionvector. The reference pixels for the SAD may be the set of 9 pixels inthe previous line starting at a horizontal location of hPos−6. The SADis computed between the reference pixels and 9 different blockprediction candidateVector's (−1, −3, −4, −5, −6, −7, −8, −9, and −10)pointing to the previous line's pixels. The 9-pixel SAD is computed as asum of 3 3-pixel SAD's (see FIG. 21). First, each absolute differencemay be truncated and clipped before being summed in the 3-pixel SADaccording to:

-   -   modifedAbsDiff=MIN(absDiff>>(maxBpc−7), 0x3F);

where maxBpc is the bit depth for the current component.

The resulting 6-bit modifiedAbsDiff values are summed over each set ofthree adjacent samples and over the 3 components, resulting in a 10 bitvalue that represents the 3×1 partial SAD for one component; this 10-bitvalue is clamped to 9-bits (e.g., values greater than 511 are clamped to511). Three 9-bit 3-pixel partial SAD's are summed to get the final9-pixel SAD, which is an 11-bit number. The 3 LSB's of each 9×1 SAD aretruncated before comparison:

-   -   bpSad[candidateVector]=MIN(511, sad3×1_0        [candidateVector]+sad3×1_1 [candidateVector]+sad3×1_2        [candidateVector]);

The 9 9-pixel SAD's are compared to one another, and the lowest SAD maybe selected, with ties broken by selecting the smallest magnitude blockprediction vector. If the lowest SAD block prediction vector is −1, thebpCount counter is reset to zero and MMAP is selected for this group. Ifthe lowest SAD block prediction vector is not −1, the candidate BPvector becomes the vector with the lowest SAD, and the bpCount counteris incremented unless hPos<9.

BP may be selected if the following conditions are all true:

The bpCount value is greater than or equal to 3.

lastEdgeCount is less than 9. The lastEdgeCount value represents thenumber of pixels that have gone by since an “edge” occurred. An “edge”occurs when ABS(current sample−left sample)>32<<(bits_per_component−8)for any component.

Selecting Between BP/MMAP and MPP

The encoder may decide whether to use BP/MMAP based on the size of thequantized residuals that would be generated if BP/MMAP were selected.For example, the encoder may determine the maximum residual size forBP/MMAP for each of the three components. If the maximum residual sizefor any component is greater than or equal to a threshold such asmaxBpc−qLevel for that component, then MPP may be selected for thatcomponent.

In addition, the encoder may select MPP in order to enforce a minimumdata rate to prevent underflow.

Quantization

The predicted value of each sample of the pixel is subtracted from thecorresponding input samples to form the residual sample values E, onefor each component of the pixel.

-   -   E=x−Px, where x is input, Px is predicted value.

Each residual value E may be quantized using division with truncation bya divisor that is a power of 2 and using rounding with a rounding valuethat is 1 less than half the divisor.

If E<0 QE = (E−ROUND)/DIVISOR Else QE = (E+ROUND)/DIVISOR // the “/”operator is div with truncation as in C

Where:

-   -   DIVISOR=2**qLevel=1<<qLevel    -   ROUND=DIVISOR/2−1

The value of qLevel may be different for luma and chroma and isdetermined by the rate control (RC) function.

MPP quantized residuals may be checked to ensure that their sizes do notexceed a threshold such as maxBpc−qLevel, where qLevel is thequantization level for the component type (luma or chroma) and maxVal isthe maximum possible sample value for the component type. If an MPPresidual exceeds this size, the encoder may change the residual to thenearest residual with a size of maxBpc−qLevel.

Inverse Quantization and Reconstruction

The encoder may follow the same process used in the decoder to arrive atthe reconstructed pixel values. For pixels that are predicted usingMMAP, BP, or MPP, the reconstructed sample value may be:

-   -   reconsample=CLAMP(predSample+(quantized_residual<<qLevel), 0,        maxVal);

where predSample is the predicted sample value, quantized_residual isthe quantized residual, qLevel is the quantization level for thecomponent type (luma or chroma), and maxVal is the maximum possiblesample value for the component type.

Flatness QP Override

FIG. 22 shows an example 2200 of original pixels used for encoderflatness checks. Encoders generate a “flatness signal” if upcoming inputpixels are relatively flat to allow the QP to drop quickly. The encoderalgorithm to determine the flatness bits in the syntax is describedbelow, as is the algorithm that both the encoder and decoder follow tomodify the QP.

Encoder Flatness Decision

A set of 4 consecutive groups is called a supergroup. The encoderexamines each supergroup before it is encoded in order to determinewhich, if any, of the groups are “flat”. The first supergroup startswith the 2nd group in the slice as shown in FIG. 22. Supergroups may bedefined consecutively within the slice. A supergroup that includes thelast group of a line may wrap around to include groups on the subsequentline.

The flatness determination may be done for each group within thesupergroup independently and includes a determination of the “flatnesstype” (e.g., either somewhat flat or very flat) for each group. Twoflatness checks may be performed, both using pixels from the original,uncompressed image.

Flatness check 1 determines the MAX and MIN value among the samplesshown in FIG. 22 for each component. A value of flatQLevel is determinedfor each component:

flatQLevel=MapQpToQlevel(MAX(0, masterQp−4));

The masterQp value that is used is the one that is used for rate controlfor the 2nd group to the left of the supergroup that is being tested.MapQptoQlevel maps the masterQP value to qLevelY (luma) and qLevelC(chroma) values that are used for both luma and chroma. For example, amasterQP value of 0 may map to qLevelC and qLevelY values of 0, values 1and 2 may map to qLevelC values of 1 and 2 respectively, and successiveunit increases in masterQP may map to unit increases alternating betweenqLevelY and qLevelC.

If the MAX−MIN for any component is greater than(2<<(bits_per_component−8)), the check for very flat fails for flatnesscheck 1; otherwise, it passes. If the MAX−MIN for any component isgreater than QuantDivisor[flatQLevel], the check for somewhat flat failsfor flatness check 1; otherwise, it passes.

If flatness check 1 indicates that the group is either somewhat flat orvery flat, that result is the final result that is used for the group.If both fail, flatness check 2 is performed over the 6 pixels indicatedin FIG. 22. The same comparisons are done as in flatness check 1, exceptthat the MAX and MIN are computed over 6 samples rather than 4. Thefinal result of flatness check 2 is then used as the final result forthe group.

For a given supergroup, there are then four flatness indications ofeither not flat, somewhat flat, or very flat. The value of prevlsFlat isinitialized to 1 if the previous supergroup had a flatness indication;otherwise it is initialized to 0. The following algorithm is used todistill the flatness information into a single flatness location andtype:

Loop over four groups in supergroup { If !prevIsFlat && group is eithervery flat or somewhat flat Current group and flatness type is signaledElse  prevIsFlat = 0; }

If no group is selected, no QP modification is made and flatness_flagfor the supergroup is set to 0 in the entropy decoder. If a group isselected, the flatness_flag for the supergroup is set to 1, and thecorresponding group is signaled as the first_flat group in the bitstream along with its associated flatness_type. The entropy encoder willonly signal flatness_flag if the masterQp value is within the range offlatness_min_qp and flatness_max_qp, so no adjustment is made in the RCif the corresponding masterQp is out of range.

The encoder flatness searches do not span to the next line. If a groupwithin a supergroup falls on the next line, it is not considered to beflat. However, the first group of a line may contain thenext_flatness_flag syntax element assuming the syntax allows it at thatpoint (see section Error! Reference source not found.).

Flatness QP Adjustment

The encoder and decoder make the same QP adjustment for a group where aflatness indication has been made. The RC receives a flatness signalcorresponding to a particular group within a supergroup that may beeither “somewhat flat” or “very flat”. It should be noted that if thecurrent masterQp is less than 7<< (2*(bits_per_component−8)), theflatness indication may be assumed to be “somewhat flat”.

For a “very flat” signal, the QP is adjusted as follows:

-   -   masterQp=1<<(2*(bits_per_component−8));

For a “somewhat flat” signal:

-   -   masterQp=MAX(stQp−4, 0);

If there is no flatness signal for a particular group:

-   -   masterQp=stQp

If the flatness QP override modifies the masterQp, the modified masterQpis used as the starting point for the short-term rate control on thenext RC cycle.

2D DPCM Coding

In the example encoders discussed above, the encoders may perform codingon in raster scan order (left to right, top to bottom). In anotherimplementation, however, the encoder operates on two dimensional sets ofsamples. That is, the encoder may encode in an order that differs fromraster scan order. For example, the encoder may encode in raster scanorder within a block, with multiple blocks ordered in raster orderwithin an image. Each block may have a height greater than one line, anda width less than the entire width of the image, for example. A blockmay be square, with a size of 4×4, 8×8, or some other size. Such a blockmay be referred to as a 2D block. Note that the encoder may employdifferential pulse-code modulation (DPCM) for encoding the 2D blocks.

A sample may be a component of a pixel, or a sample may be an element ofa matrix of samples of a single component. If there are multiplecomponents, the matrices of the components may or may not coincide. Theuse of the word pixel may refer to a sample, and the samples ofdifferent components may not be co-located. DPCM coding of sampleswithin a 2D block may resemble DPCM coding described above, withprediction of samples based on reconstructed previously coded samplevalues, finding residual values of the samples, optionally quantizingthe residual values, and coding the resulting residual values. However,in 2D DPCM the order of coding the samples may follow an order definedwithin blocks, and the blocks are coded in a selected order such asraster order. The set of samples used for prediction of sample values in2D DPCM may be based on the samples that are previously coded in thesample order used for 2D DPCM. Hence the set of samples used forprediction may differ, at least for some samples, from those used forraster order DPCM. For example, blocks may be square and samples may beencoded in raster order within each block. In this case, when codingsamples at the right edge of a block, on lines within the block afterthe first line of the block, samples above and to the right of suchsamples have not been previously coded and are not available for use inprediction of such samples. In another example, blocks may be square andsamples may be encoded in a zig-zag pattern within each block, such thata sample below and to the left of a current sample is coded previouslyto the current sample, and as such the lower left sample is availablefor use in prediction and may be used for prediction of the currentsample.

FIG. 23 shows an example of 2D blocks 2300 that the encoder may employfor 2D DPCM coding. For example, the 2D block 2302 is a 4 pixel row by 4pixel column block. The extent of the 2D blocks may vary widely in termsof the number of pixels that they include. As just a few examples, asquare 2D block may be 2×2, 3×3, 4×4, or 8×8 pixels. In otherimplementations, a 2D block may be a rectangular block 2304, triangularor pyramidal blocks 2306, L-shaped block 2308 and 2312, octagonal block2310, or have other non-square shapes. The 2D blocks may be rotatedversions of one another, and may interlock to form larger 2D shapes. Forexample, the L-shaped blocks 2312 and 2314 (as with the L-shaped blocks2308 and 2316) are rotated 180 degrees with respect to one another, andinterlock to form rectangular blocks.

Within a 2D block, the encoder may encode the pixels in a selectedorder, such as a raster scan order, by vertical stripe, by interleavedL-shaped sections, or any other order. More specifically, the encodermay encode each sample of the pixel (e.g., the R, G, and B samples) byperforming color space conversion, predicting sample values, generatingresidual values, performing quantization of residual values for some orall of the pixels in the 2D block, and performing entropy encoding onthe residual values, e.g., using the techniques discussed above,including DSU-VLC for the residual values.

FIG. 24 shows an encoding scenario 2400. The encoder has already encodedand reconstructed the pixels in the first 2D block 2402, and is workingon the second 2D block 2404. The second 2D block 2404 has available toit left neighbors that have already been reconstructed, e.g., due to theprior encoding of the first 2D block 2402. That is, the first 2D block2402 has already been encoded in an encoder, and in a decoder the first2D block 2402 has already been decoded. All of the pixels in the first2D block 2402 are available neighbors for the encoding and decoding ofthe second 2D block 2404, and the encoder may use them for prediction.Two examples are present in FIG. 24, the pixels 2406 and 2408. These twopixels are reconstructed and available for prediction of pixels in block2404. Depending on the pixel in the second 2D block that is beingencoded (e.g., the pixel 2410), the left neighbors include pixels belowand to the left of the pixel being encoded. For example, pixel 2408 isbelow and to the left of the pixel 2412. The available pixels from thefirst 2D block 2402 may improve the prediction of the current pixelundergoing encoding, e.g., the pixel 2412 or 2410.

Thus the DPCM coding for the 2D blocks may rely on reconstructed pixelsboth from the same 2D block undergoing encoding or decoding (e.g., thepixel 2412), and previously encoded or decoded 2D blocks. Further, asthe encoding or decoding moves further inside the 2D block 2404, e.g.,to the pixel 2414, then the encoding process has close reconstructedsamples available within the 2D block, e.g., the pixels 2416 and 2418.Accordingly, the 2D DPCM coding may encode or decode from inside the 2Dblock, rather than relying always on reconstructed pixels from outsideof the 2D block. Furthermore, the encoding and decoding processes mayemploy multiple different types of predictors, such as the MMAP andother predictors discussed above.

Note also that prediction may be done from many different directionsspecified by prediction vectors with respect to the current pixelundergoing encoding or decoding. Examples of prediction vectors 2420 and2422 are shown in FIG. 24 with respect to the pixel 2410. As otherexamples, the prediction vector may be to the current pixel beingprocessed from: one pixel above in the current 2D block, one pixel tothe left in the current 2D block, or two pixels to the left and onepixel down in a prior encoded 2D block. The prediction vectors are notlimited to these examples.

The output of the encoder may be one residual per sample, for eachcomponent of each pixel within the block. For example, there may be oneresidual for each R, G, and B component for each pixel, or for thecomponents of any other color space used to represent the pixel. Theencoder may group together any number of residuals into a unit, e.g.,into a unit of 2, 3, 4, or some other number of samples. The encoder mayperform entropy coding on the residuals.

In some implementations, the samples of different components are notnecessarily co-located. That is, not all the samples are necessarilypart of a pixel located at one physical location. For example, thesamples may correspond to a Bayer pattern (e.g. an RGBG, GRGB, or RGGBpattern), where each physical position corresponds to a different color.Thus, the 2D DPCM coding may operate on samples that do not necessarilyall contribute to a single physical pixel. Expressed another way, the 2DDPCM may operate on a sample that corresponds to a single physicallocation, but that location need not form a part of a larger samplegroup (e.g., R, G, B) that defines color for a particular pixel.

One aspect of 2D block DPCM is that the encoder may explicitly indicateQP, prediction, or other encoding variables in the encoded bitstream(e.g., by sending values or indicators for these variables), compared toimplicit recovery of these parameters in the decoder from the decodingprocess itself based on decoding history. The parameter indications mayuse very few bits per block, such as 1 bit per 2D block. Spending bitsper block amortizes the cost over the number of pixels in the 2D block,which may be large, and therefore makes explicit indications quiteefficient, particularly as the 2D block size increases. As a specificexample, 1 bit for a 8×8 2D block costs only ( 1/64)th of a bit perpixel for that explicit indicator. In contrast, a 1 bit indicator for 8consecutive pixels in raster scan order costs (⅛)th of a bit per pixel.

Nevertheless, the encoder and decoder may employ implicit QP andprediction whenever desired. Then, when the encoder decides to changethe QP, the prediction vector, or other parameter in a manner that thehistory does not facilitate the decoder to fully ascertain, the encodermay explicitly insert bits into the bitstream in a bit cost efficientway to inform the decoder of the new QP or other parameter value. Thisprovides a type of hybrid implicit/explicit signaling of QP, prediction,and other parameters.

As one specific example, the encoder may use, e.g., one operational modebit per 2D block to indicate whether or not the decoder should proceedwith implicitly obtaining parameters. When the operational mode bit isset, for instance, the decoder may proceed with implicit determinationof the parameters. But when the bit is cleared, the encoder may providea parameter indicator in the bitstream and override or modify theimplicit operation of the decoder for that 2D block. The parameterindicator may be, as examples, an explicit QP value, an indication toraise or lower QP, an indicator to turn on or off block prediction, oran explicit value for a prediction vector.

Another aspect to 2D block DPCM is that it may benefit from better blockprediction. Within a picture, intrapicture prediction vectors mayfacilitate the prediction for the 2D block by specifying or pointing toprior blocks that should be used for the prediction of the 2D blockcurrently being encoded. With 2D DPCM, bits can be allocated to specifya prediction vector. With the amortization across all of the bits in the2D block, the cost of explicitly specifying a prediction vector in thebitstream may have a low enough bit cost to make the bit expenditureacceptable for the use of the explicit prediction vectors.

The encoder may use DPCM to predict each pixel within the 2D block, andmay predict some or all of the many of the pixels within the 2D block atleast in part from values of other pixels within the same 2D block. Thismay result better quality compression than either transform based codingor transform bypass coding. In various embodiments of the presentdisclosure, quantization may be applied to at least some or many of thepixels within a block.

The two-dimensional arrangement of pixels in a 2D block results in asmall spatial extent of the block in both dimensions. The spatial extenttends to yield efficient image coding, while having a larger number ofpixels per block than would have been obtained from a one dimensionalblock with the same extent. As noted above, the larger number of pixelsper block amortizes the bit cost of the bits used to indicateinformation related to the decoding of the block, for example, the bitsthat indicate QP and prediction controls.

As noted above, in one implementation, for a 2D block of pixels, one (ormore) bit per block indicates whether implicit or explicit prediction isused for that block. If explicit prediction is used, another one or morebits indicates which prediction type and mode are used for that block.The types and modes that may be indicated include, as examples, spatialprediction and block prediction. Spatial prediction may be similar tothe spatial prediction specified in AVC and/or H.264. Block predictionmay also be employed. Alternatively, explicit prediction may only employblock prediction. Note that implicit prediction may use a form ofspatial prediction of each sample, for example, the prediction describedabove with respect to FIGS. 4 and 5.

With the DPCM encoding, the encoder may combine block prediction withtwo-dimensional DPCM as well as either explicit prediction and/or hybridimplicit-explicit prediction. Furthermore, the encoder may use DPCM forsome 2D blocks and transform coding for other 2D blocks, and switchbetween the two as desired, e.g., on a block-by-block basis, accordingto specific types of content or as signaled by an external controller.Transform coding may employ spatial and/or block prediction, with onetype selected per block, followed by transformation and quantization ofthe residual, and entropy coding. Further, in some implementations, theencoder may switch between 2D blocks and a 1D set of pixels (e.g., the1×3 “blocks” described above), e.g., at the end of a set of lines in animage. Further, the encoder may encode some or all pixels or samples ina 2D block using Indexed Color History (ICH) as described above.

In other implementations, the encoder may switch between different sizesof 2D blocks. For instance, the encoder may switch from 4×4 blocks forvarious sets of 4 image lines, switch to 16×16 blocks for different setsof 16 image lines, and switch to 8×8 blocks for yet different sets of 8image lines. Further, within a given 2D block, the encoder may encode onthe basis of sub-blocks. For example, an 8×8 block may have four 4×4sub-blocks defined within it. The encoder may choose any desiredencoding technique for each of the 4×4 sub-blocks, such as 2D DPCM,transform coding, or other coding technique.

The encoder may also enhance DSU-VLC for transform coding. Take a given2D block size, e.g., 4×4. After transform and quantization, the encoderhas a 4×4 array of quantized values. Those may be ordered by a selectedscan sequence through the array and converted into a one dimensionalseries of numbers, e.g., 16 numbers for a 4×4 array.

The encoder may then arrange the numbers according to a selected orderinto groups that cover all 16 samples in the series of numbers. Thegroup sizes may be consistent between 2D blocks. For instance, a groupsize may be one DC component for each 2D block, and another group sizemay be six high frequency components for each 2D block. There are manyways to cover all the residuals, and one example using five groups for16 residuals is {1}, {2:4}, {5:8}, {9:12}, {13:16}, and one exampleusing four groups is {1}, {2:5}, {6:10}, {11:16}, where the numbers inbraces indicate the quantized transformed coefficients in scan order.

The encoder may then encode each group using DSU-VLC. Thus, for example,the groups may include a group which is a DC component value with asignificantly non-zero value. A group of the last several terms may bethe high frequency terms with zero values. A middle group may haveintermediate frequency terms with intermediate values. The enhancedDSU-VLC may encode a group using previously coded groups of the samecomponents. For instance, the size of the DC component group may bepredicted from the previous DC component group, with the prediction (thedelta size) difference then determined, and the residual coded with thevariable length code. For instance, the size of the high frequency groupmay be predicted from the previous high frequency group of the samecomponent.

FIG. 25 shows an example of encoder logic 2500. The encoder logic 2500obtains the image to be encoded (2502). The image may be stored in abuffer for the encoder, or the image may be streamed to the encoder, asexamples. The encoder logic determines a 2D block configuration forencoding the image (2502). As examples, the 2D block configuration maybe a 2×2, 4×4, 8×8, rectangular, or other 2D block. The encoder logic2500 also determines which of potentially several different encodingtechniques to use for the 2D block (2506).

When DPCM is selected, the encoder logic 2500 performs 2D DPCM encodingof a block of image components in the image (2508). The components maybe color space components, e.g., R, G, B components for a single pixel,or individual components (e.g., Bayer pattern components), as examples.The encoding may include: using intra-block reconstructed pixels forencoding other pixels within the same 2D block (2510) as well as usingreconstructed neighbor pixels from previously coded 2D blocks forencoding pixels within the 2D block (2512). However, as noted above, theencoder may switch between different encoding techniques for the 2Dblocks. As another example, the encoder logic 2500 may apply transformcoding (e.g., Discrete Cosine Transform (DCT) coding) to a particular 2Dblock (2514).

The encoding logic 2500 generates a bitstream that encodes the image(2516). In that regard, the bitstream may include entropy encodedresiduals, for example. The entropy encoded residuals may result fromDSU-VLC encoding as described above, including DSU-VLC encodingaccording to predetermine group sizes that cover the samples in the 2Dblock. Note also that the encoding logic 2500 may create the bitstreamas a hybrid implicit/explicit encoding bitstream.

In that regard, the encoding logic 2500 may insert an operational modebit in the bitstream for the encoded 2D block that differentiatesbetween implicit encoding parameter determination and explicit encodingparameter determination (2518). For instance, the encoding logic 2500may clear the operational mode bit in the bitstream to select explicitencoding parameter determination, and insert an encoding parameterindicator into the bitstream. Explicit parameter determination mayinclude an adjustment to an implicitly determined parameter value, byspecifying the adjustment as the encoding parameter in the bitstream.The encoding parameter may include a quantization parameter indicator,prediction vector indicator, or other parameter. Further, the encodinglogic 2500 may set the operational mode bit in the bitstream to selectimplicit encoding parameter determination.

The methods, devices, and logic described above may be implemented inmany different ways in many different combinations of hardware, softwareor both hardware and software. For example, all or parts of the systemmay include circuitry in a controller, a microprocessor, or anapplication specific integrated circuit (ASIC), or may be implementedwith discrete logic or components, or a combination of other types ofanalog or digital circuitry, combined on a single integrated circuit ordistributed among multiple integrated circuits. All or part of the logicdescribed above may be implemented as instructions for execution by aprocessor, controller, or other processing device and may be stored in atangible or non-transitory machine-readable or computer-readable mediumsuch as flash memory, random access memory (RAM) or read only memory(ROM), erasable programmable read only memory (EPROM) or othermachine-readable medium such as a compact disc read only memory (CDROM),or magnetic or optical disk. Thus, a product, such as a computer programproduct, may include a storage medium and computer readable instructionsstored on the medium, which when executed in an endpoint, computersystem, or other device, cause the device to perform operationsaccording to any of the description above.

The processing capability of the system may be distributed amongmultiple system components, such as among multiple processors andmemories, optionally including multiple distributed processing systems.Parameters, databases, and other data structures may be separatelystored and managed, may be incorporated into a single memory ordatabase, may be logically and physically organized in many differentways, and may implemented in many ways, including data structures suchas linked lists, hash tables, or implicit storage mechanisms. Programsmay be parts (e.g., subroutines) of a single program, separate programs,distributed across several memories and processors, or implemented inmany different ways, such as in a library, such as a shared library(e.g., a dynamic link library (DLL)). The DLL, for example, may storecode that performs any of the system processing described above.

Various implementations have been specifically described. However, manyother implementations are also possible.

The invention claimed is:
 1. A method comprising: determining a twodimensional mxn block of pixels within an image for coding the image;coding the pixels in the two dimensional mxn block of pixels using twodimensional differential pulse code modulation to generate coded pixels,wherein the coding comprises: obtaining a first reconstructed pixelwithin the two dimensional mxn block; and coding a second, different,pixel within the two dimensional mxn block using the reconstructedpixel; implicitly determine a value of a coding variable for the twodimensional mxn block of pixels; expressly signaling an adjustment valuefor the implicitly determined value of the coding variable for the twodimensional mxn block using an indicator, wherein the coding variablecomprises a quantization level for the coding of the two dimensional mxnblock; amortizing a coding cost of the indicator over each pixel of thetwo dimensional mxn block of pixels by controlling the coding in accordwith the indicator for each pixel of the two dimensional mxn block ofpixels; and inserting the coded pixels and the indicator into abitstream.
 2. The method of claim 1, where coding comprises: obtaining asecond reconstructed pixel from a different two dimensional block ofpixels in the image; and coding a third, different, pixel within the twodimensional mxn block using the second reconstructed pixel.
 3. Themethod of claim 1, where coding comprises: obtaining a secondreconstructed pixel from a different two dimensional block of pixels inthe image; and coding a third, different, pixel within the twodimensional mxn block using the reconstructed pixel.
 4. The method ofclaim 1, where coding comprises: determining entropy coded residualvalues during the coding; and creating a bitstream comprising theentropy coded residual values.
 5. The method of claim 4, where creatinga bitstream comprises: creating a hybrid implicit/explicit codingbitstream.
 6. The method of claim 5, where creating a hybridimplicit/explicit bitstream comprises: inserting an operational mode bitin the bitstream that differentiates between implicit coding parameterdetermination and explicit coding parameter determination.
 7. The methodof claim 6, where inserting the operational mode bit comprises:inserting an operational mode bit with a selected value in the bitstreamto select explicit coding parameter determination.
 8. The method ofclaim 1, further comprising: coding a different two dimensional block ofpixels in the image using a two dimensional coding technique other thantwo dimensional differential pulse code modulation.
 9. The method ofclaim 1, where coding comprising encoding the two dimensional mxn blockof pixels, decoding the two dimensional mxn block of pixels, or both.10. A system comprising: a buffer configured to store image data of animage; and coding circuitry in communication with the buffer andconfigured to: determine, among the image data, a first two dimensionalmxn block of pixels; code the first two dimensional mxn block of pixelsusing two dimensional differential pulse code modulation, the codingcomprising: obtain a reconstructed pixel within the first twodimensional mxn block; and code a second, different, pixel within thefirst two dimensional mxn block using the reconstructed pixel;implicitly determine a value of a coding variable for the twodimensional mxn block of pixels; explicitly signal an adjustment valuefor the implicitly determined value of the coding variable for the firsttwo dimensional mxn block of pixels using an indicator, the codingvariable comprising a quantization level; amortize a coding cost of theindicator over each pixel of the first two dimensional mxn block ofpixels by controlling the coding in accord with the indicator for eachpixel of the first two dimensional mxn block of pixels; and insert thecoded pixels and the indicator into a bitstream.
 11. The system of claim10, where: the first two dimensional mxn block of pixels comprisesmultiple rows and multiple columns; and m comprises the same integervalue as n.
 12. The system of claim 10, where the coding circuitry isfurther configured to: obtain a second reconstructed pixel from asecond, different, two dimensional block of pixels in the image; andcode a third, different, pixel within the first two dimensional mxnblock using the reconstructed pixel.
 13. The system of claim 10, wherethe coding circuitry is further configured to: create a bitstreamcomprising: coding results obtained by the two dimensional differentialpulse code modulation; and an operational mode bit that differentiatesbetween implicit coding parameter determination and explicit codingparameter determination.
 14. The system of claim 10, wherein theindicator for a second two dimensional mxn block in the bitstreamcomprises an explicit coding parameter indicator that specifies a changewith respect to the quantization level of the first two dimensional mxnblock.
 15. A system comprising: a buffer configured to store image dataof an image; and coding circuitry in communication with the buffer andconfigured to: determine, among the image data, a first two dimensionalblock of pixels; code the first two dimensional block of pixels usingtwo dimensional differential pulse code modulation, including: obtaininga reconstructed pixel within the first two dimensional block; and codinga second, different, pixel within the first two dimensional block usingthe reconstructed pixel; determine, among the image data, a second twodimensional mxn block of pixels; code the second two dimensional mxnblock of pixels using a transform coding technique; determine entropycoded residual values for the two dimensional differential pulse codemodulation coding and for the transform coding; implicitly determine avalue of a coding variable for the second two dimensional mxn block ofpixels; explicitly signal an adjustment value for the implicitlydetermined value of the coding variable for the second two dimensionalmxn block of pixels using an indicator, the coding variable comprising aquantization level; amortize a coding cost of the indicator over eachpixel of the second two dimensional mxn block of pixels by controllingthe coding in accord with the indicator for each pixel of the second twodimensional mxn block of pixels; and create a bitstream comprising theentropy coded residual values and the indicator.
 16. The system of claim15, where the bitstream comprises: a first operational mode bit for thefirst two dimensional block, the first operational mode configured toselect implicit mode determination of coding parameters; and a secondoperation mode bit for the second two dimensional mxn block, the secondoperational mode bit configured to select explicit mode determination ofcoding parameters; and where the indicator comprises a coding parameterindicator associated with the second two dimensional mxn block.
 17. Thesystem of claim 15, where the indicator comprises: a first codingindicator specifying two dimensional differential pulse code modulationfor the first two dimensional block of pixels; and a second codingindicator specifying transform coding for the second two dimensional mxnblock of pixels.